Current mainstream AI, at least as presented in media and measured by the number of people involved and papers published, is mainly about big data, deep learning, and recently trendy large language models. All these are techniques that are data-driven, model-free, and number-crunching. Their immense success in some areas, such as computer vision and natural language processing, started the next hype in the era of AI, which brings a question whether neural approaches, after being dismissed at the beginning of the AI era, finally conquered the world of AI and proved applicable to every problem. A deeper look at these new techniques shows they have similar issues as the old-fashioned AI techniques in the past: brittleness, making strange mistakes, and being highly dependent on data used for training. Moreover, there are problems with the explainability of results and no guarantees provided, which is a crucial issue in some application areas. In this paper, we look at core principles of the neural ML techniques, that is, being data-driven rather than knowledge-based and being model-free rather than model-based, and we argue that symbolic knowledge models can still contribute to the design of trustworthy and explainable AI systems. Specifically, we focus on hierarchical reasoning, namely hierarchical planning, which is useful for highly complex problems but is not addressed by current neural models. We propose a research plan consisting of solving specific problems in hierarchical planning as an example of a knowledge-intensive approach to problem-solving. We show close connections between these problems that allow a smooth transition between solving techniques used to solve these problems. We also propose an ultimate goal of this endeavor, that is, autonomous construction of hierarchical planning models, that addresses the crucial problem of knowledge-based approaches -- how to obtain a formal model (extract knowledge from data).

Plan verification deals with the problem of checking whether a given sequence of actions is a valid plan according to a planning domain model. If the action sequence is not a valid plan, the next question is where the problem is. This question can be addressed by plan correction – modifying the plan to get a valid plan. The paper presents the first system to correct totally ordered hierarchical plans by action deletion and action insertion. Supporting action insertion, which is the major novelty here, significantly extends the applicability of plan correction to areas such as plan recognition and even planning itself. The new system is also faster than the existing plan correction system when only action deletion is allowed.

Multi-agent path-finding is a problem where we navigate agents to their destinations without collisions with other agents. We use a distributed approach to solve the problem that does not rely on centralized planning or direct communication between agents. In- stead of a centralized approach, we introduce so-called social laws that restrict an agent from executing certain actions according to its local environment in order to avoid con- flicts between agents. In this paper, we show their applicability in multi-agent pathfinding problem. These techniques have been designed and tested on various test maps for dif- ferent numbers of agents.

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.

Hierarchical task network (HTN) planning extends classical planning by incorporating a hierarchy of tasks that gives plans additional structure and speeds up planning. However, it requires that each action be part of some task in the domain model, which makes it less flexible when the task hierarchy does not capture all the possibilities to achieve every task. HTN planning with task insertion (TIHTN planning) extends HTN planning by allowing the insertion of actions outside the hierarchy, thus giving more flexibility to constructing hierarchical plans. TIHTN planning has been proposed as a theoretical concept to show some decidability and complexity results. This paper describes an implemented TIHTN planner for totally ordered domains utilizing top-down grammar parsing.

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.

Multi-agent pathfinding is the task of navigating a set of mobile agents in a shared environment such that they avoid collisions. Finding an optimal solution in terms of the length of the plan is known to be a computationally hard problem (NP-Hard). In general, there are two schools of optimal algorithms: search-based and reduction-based. While search-based algorithms excel in solving large maps where few conflicts can be expected, reduction-based algorithms excel in smaller instances even when agents interact often. However, the reduction-based approaches lag behind in large instances, even with few agents. To mitigate this, a subgraph pruning method was introduced to prune unnecessary vertices to decrease the size of the instance. The pruning is based on the shortest paths for each agent. In the original study, the authors randomly selected the shortest routes. In this study, we replicate the overall approach while selecting the initial shortest path with more care. We provide several approaches for selecting one of the possible shortest paths and experimentally compare them. We note that when the makespan optimal plan is needed, not all agents are required to use the shortest path, as only the longest path dictates the makespan. Using this observation, we also introduce an approach that selects longer paths for some agents if it helps to reduce the total number of interactions between agents. We provide an experimental comparison of all proposed approaches and show that the latter performs significantly better, in most cases outperforming any approach that strictly selects only the shortest path.

The performance of a heuristic search depends substantially on the quality of its heuristic functions. A preferred heuristic is accurate, fast to query, and takes little memory. Recent research has explored two routes for building highperformance heuristics. Memory-based heuristics use a precomputed database containing optimal distances between a set of pivot states and all other states in the search graph. More pivot states tend to increase heuristic accuracy while slowing down heuristic computation and increasing memory cost. Alternatively, formula-based heuristics produced via program synthesis capture information about the search graph in short, human-readable formulae. These formulae have negligible memory cost and are fast to query, but generally perform worse than a memory-based heuristic. This paper presents the first empirical comparison between the two approaches for pathfinding. We find that formulabased heuristics can yield better performance than memorybased heuristics with a small number of pivots while being still more compact. With more pivots memory-based heuristics yield better speed-ups but take orders of magnitude more memory. We then investigate the degradation of search performance as the map changes and find that the performance of formula-based heuristics degrades more gracefully than that of memory-based heuristics.

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.

In this paper, we consider the plan verification problem for totally ordered (TO) HTN planning. The problem is proved to be solvable in polynomial time by recognizing its connection to the membership decision problem for context-free grammars. Currently, most HTN plan verification approaches do not have special treatments for the TO configuration, and the only one features such an optimization still relies on an exhaustive search. Hence, we will develop a new TOHTN plan verification approach in this paper by extending the standard CYK parsing algorithm which acts as the best decision procedure in general.

Earley Parser is a top-down parser proposed for context-free grammars and used, for example, in the grammar constraint. Parsing trees of context-free grammars are very close to task decomposition trees used in hierarchical planning, specifically when the actions are totally ordered. This paper suggests using the Earley Parser to recognize totally ordered hierarchical plans. Given a sequence of actions – a prefix of the plan – and a task decomposition model, the plan recognition problem asks which task decomposes to a plan containing the given plan prefix. We will show that the Earley parser significantly increases the speed of plan recognition compared to the existing bottom-up parsing-based plan recognizer. The Earley parser’s performance is also on a par with the planning-based plan recognizer despite not using any planning heuristics.

The problem of hierarchical plan verification focuses on checking whether an action sequence is a valid hierarchical plan the action sequence is executable and a goal task can be decomposed into it. The existing parsing-based verifier works on lifted domain models. In this paper we study whether grounding of the models could improve efficiency of the verifier. We also explore additional implementation improvements to increase the speed of the verifier.

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.

There are multiple formalisms describing hierarchical planning domain models, however many of them do not show semantics of some features such as empty decomposition methods and extensive constraints. In this short paper we describe the semantics of a hierarchical domain model with these extensive constraints and show how empty decomposition methods would work within it. We also compare this model with other models and present some transformations of model properties.

Multi-agent pathfinding is the task of navigating a set of agents in a shared environment without collisions. Finding an optimal plan is a computationally hard problem, therefore, one may want to sacrifice optimality for faster computation time. In this paper, we present our preliminary work on finding a valid solution using only a predefined path for each agent with the possibility of adding wait actions. This restriction makes some instances unsolvable, however, we show instances where this approach is guaranteed to find a solution.

This paper extends a study on improving the performance of reduction-based solvers for the problem of multi-agent pathfinding. The task is to navigate a set of agents in a graph without collisions. Solvers that reduce this problem to other formalisms often have issues scaling to larger instances in terms of the graph size. A previous study suggests that pruning the graph of most vertices based on a randomly chosen shortest path for each agent. In this paper, we study the effect of different choices of these paths.

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.

Multi-agent Path Finding (MAPF) deals with finding collision-free paths for a set of agents on a graph, where each agent has its origin and destination. Colored MAPF is a generalization of MAPF, where groups of agents are moving, and the set of destination nodes is specified per group rather than per agent. OzoMorph is software providing an intuitive user interface for specifying Colored MAPF problems, solving them by translation to SAT, and finally visualizing the solution either in a computer simulation or by converting the plans to executable instructions for Ozobot Evo robots.

Verifying HTN plans is an intractable problem with two existing approaches to solve the problem. One technique is based on compilation to SAT. Another method is using parsing, and it is currently the fastest technique for verifying HTN plans and the only technique supporting state constraints. In this paper, we propose an extension of the parsing-based approach to verify totally-ordered HTN plans more efficiently. This problem is known to be tractable if no state constraints are included, and we show theoretically and empirically that the modified parsing approach achieves better performance than the currently fastest HTN plan verifier when applied to totally-ordered HTN plans.

Multi-agent Path Finding deals with finding collision-free paths for a set of agents moving in a shared environment. Due to uncertainty during execution, agents might be delayed, which may bring collisions among them. In the paper, we propose using contingent planning to generate plans robust to delays. The initial plan is analyzed to find locations for possible collisions, and alternative paths are planned to divert delayed agents before the collision occurs. This novel concept of robustness guarantees no collisions (until some maximum delay), it does not prolong the execution of plans if the delay does not occur, and it does not significantly extend the planning time.

Hierarchical task network (HTN) planning is a model-based approach to planning. The HTN domain model consists of tasks and methods to decompose them into subtasks until obtaining primitive tasks (actions). There are recent methods for verifying if a given action sequence is a valid HTN plan. However, if the plan is invalid, all existing verification methods only say so without explaining why the plan is invalid. In the paper, we propose a method that corrects a given action sequence to form a valid HTN plan by deleting the minimal number of actions. This plan correction explains what is wrong with a given action sequence concerning the HTN domain model.

Multi-Agent Path Finding (MAPF) deals with the problem of finding collision-free paths for a set of agents moving in a shared environment, while each agent has specified its own destination. Colored MAPF generalizes MAPF by defining groups of agents that share a set of destination locations. In the paper, we evaluate several approaches to optimally solve colored MAPF problem, namely, a method based on network flows, an extended version of conflict-based search, and two models using Boolean satisfiability. We also investigate methods for obtaining lower bounds on optimal solutions based on constraint and continuous relaxation techniques.

A classical approach to Multi-agent Path Finding assumes an offline construction of collision-free paths that the agents blindly follow during execution. k-robust plans can be executed without collisions even if an agent is delayed for at most k steps. In the paper, we propose a novel concept of robustness that uses alternative paths to which the agents are diverted in case of delay. Such plans can be found with much higher chances than k-robust plans.

Multi-Agent Path Finding (MAPF) deals with finding collision free paths for a set of agents (robots) moving on a graph. The interest in MAPF in the research community started to increase recently partly due to practical applications in areas such as warehousing and computer games. However, the academic community focuses mostly on solving the abstract version of the problem (moving of agents on the graph) with only a few results on real robots. The presented software MAPF Scenario provides a tool for specifying MAPF problems on grid maps, solving the problems using various abstractions (for example, assuming rotation actions or not), simulating execution of plans, and translating the abstract plans to control programs for small robots Ozobots. The tool is intended as a research platform for evaluating abstract MAPF plans on real robots and as an educational and demonstration tool bridging the areas of artificial intelligence and robotics.

Hierarchical Task Networks were proposed as a method to describe plans by decomposition of tasks to subtasks until primitive tasks, actions, are obtained. Valid plans - sequences of actions - must adhere both to causal dependencies between the actions and to the structure given by the decomposition of the goal task. Plan verification aims at finding if a given plan is valid, that is, if it is causally consistent and it can be obtained by decomposition of some task. The paper describes a novel parsing-based approach for hierarchical plan verification that is orders of magnitude faster than existing methods.

Multi-Agent Path Finding (MAPF) deals with finding collision-free paths for a set of agents. It is a special case of a planning problem with only two actions - move and wait - and with one major constraint of no collision between the agents. The paper addresses the question of how to model MAPF as a classical sequential planning problem. Several models in the PDDL language are proposed and empirically compared.

Multi-agent path-finding (MAPF) is the problem of finding a plan for moving a set of agents from their initial locations to their goals without collisions. Following this plan, however, may not be possible due to unexpected events that delay some of the agents. In this work, we propose a holistic solution for MAPF that is robust to such unexpected delays. First, we introduce the notion of a k-robust MAPF plan, which is a plan that can be executed even if a limited number (k) of delays occur. We propose sufficient and required conditions for finding a k-robust plan, and show how to convert several MAPF solvers to find such plans. Then, we propose several robust execution policies. An execution policy is a policy for agents executing a MAPF plan. An execution policy is robust if following it guarantees that the agents reach their goals even if they encounter unexpected delays. Several classes of such robust execution policies are proposed and evaluated experimentally. Finally, we present robust execution policies for cases where communication between the agents may also be delayed. We performed an extensive experimental evaluation in which we compared different algorithms for finding robust MAPF plans, compared different ro- bust execution policies, and studied the interplay between having a robust plan and the performance when using a robust execution policy.

Multi-agent pathfinding (MAPF) is the problem of moving a group of agents to a set of target destinations while avoiding collisions. In this work, we study the online version of MAPF where new agents appear over time. Several variants of online MAPF are defined and analyzed theoretically, showing that it is not possible to create an optimal online MAPF solver. Nevertheless, we propose effective online MAPF algorithms that balance solution quality, runtime, and the number of plan changes an agent makes during execution.

The problem of multi-agent path finding (MAPF) is studied in this paper. Solving MAPF optimally is a computationally hard problem and many different optimal algorithms have been designed over the years. These algorithms have good runtimes for some problem instances, while performing badly for other instances. Interestingly, these hard instances are often different across the algorithms. This leads to an idea of combining the strengths of different algorithms in such a way that an input problem instance is split into disjoint subproblems and each subproblem is solved by appropriate algorithm resulting in faster computation than using either of the algorithms for the whole instance. By manual problem decomposition we will empirically show that the above idea is viable. We will also sketch a possible future work on automated problem decomposition.

Multi-agent path finding (MAPF) is the problem to find collision-free paths for a set of agents (mobile robots) moving on a graph. There exists several abstract models describing the problem with various types of constraints. The demo presents software to evaluate the abstract models when the plans are executed on Ozobots, small mobile robots developed for teaching programming. The software allows users to design the grid-like maps, to specify initial and goal locations of robots, to generate plans using various abstract models implemented in the Picat programming language, to simulate and to visualise execution of these plans, and to translate the plans to command sequences for Ozobots.

Multi-agent path finding (MAPF) deals with the problem of finding collision-free paths for a set of agents. Each agent moves from its start location to its destination location in a shared environment represented by a graph. Reduction-based solving approaches for MAPF, for example reduction to SAT, exploit a time-expended layered graph, where each layer corresponds to specific time. Hence, these approaches are natural for minimizing makespan (the shortest time till all agents reach their destinations). Modeling the other frequently used objective, namely Sum of Costs (SOC; sum of paths lengths of all agents) is more difficult as the solution with the smallest SOC may not be reached in the time-expended graph with the smallest makespan. In this paper we suggest two novel approaches to estimate the makespan, that guarantees existence of a SOC-optimal solution. The approaches are empirically compared with an existing reduction-based method as well as with the state-of-the-art search-based optimal MAPF solver.

The multi-agent pathfinding problem (MAPF) is the fundamental problem of planning paths for multiple agents, where the key constraint is that the agents will be able to follow these paths concurrently without colliding with each other. Applications of MAPF include automated warehouses, autonomous vehicles, and robotics. Research on MAPF has been flourishing in the past couple of years. Different MAPF research papers assume different sets of assumptions, e.g., whether agents can traverse the same road at the same time, and have different objective functions, e.g., minimize makespan or sum of agents' actions costs. These assumptions and objectives are sometimes implicitly assumed or described informally. This makes it difficult for establishing appropriate baselines for comparison in research papers, as well as making it difficult for practitioners to find the papers relevant to their concrete application. This paper aims to fill this gap and facilitate future research and practitioners by providing a unifying terminology for describing the common MAPF assumptions and objectives. In addition, we also provide pointers to two MAPF benchmarks. In particular, we introduce a new grid-based benchmark for MAPF, and demonstrate experimentally that it poses a challenge to contemporary MAPF algorithms.

In the multi-agent path-finding (MAPF) problem, the task is to find a plan for moving a set of agents from their initial locations to their goals without collisions. Following this plan, however, may not be possible due to unexpected events that delay some of the agents. We explore the notion of k-robust MAPF, where the task is to find a plan that can be followed even if a limited number of such delays occur. k-robust MAPF is especially suitable for agents with a control mechanism that guarantees that each agent is within a limited number of steps away from its pre-defined plan. We propose sufficient and required conditions for finding a k-robust plan, and show how to convert several MAPF solvers to find such plans. Then, we show the benefit of using a k-robust plan during execution, and for finding plans that are likely to succeed.

Real-life scheduling has to face many difficulties such as dynamics of manufacturing environments with unforeseen events occurring during the execution of a schedule. Namely, in the case of a resource failure, it may be necessary to process a lot of work again, or a feasible schedule recovery may not exist at all. Moreover, the time window within which the ongoing schedule must be updated may be very short, and too timeconsuming computation of the schedule may lead to a failure of the scheduling mechanism and setback in production. Our approach in the area of predictive-reactive scheduling is to allow for substitution of tasks, which cannot be executed, with a set of alternative tasks. This paper makes use of the model of the hierarchical workflows and gives an SMT and a CSP models to recover an ongoing schedule from a resource failure with the objective to minimize the work processed in vain. The experimental analysis identified parameters for which the SMT model clearly outperforms the CSP model and vice versa.

The multi-agent pathfinding (MAPF) problem has attracted considerable attention because of its relation to practical applications. In this paper, we present a constraint-based declarative model for MAPF, together with its implementation in Picat, a logic-based programming language. We show experimentally that our Picat-based implementation is highly competitive and sometimes outperforms previous approaches. Importantly, the proposed Picat implementation is very versatile. We demonstrate this by showing how it can be easily adapted to optimize different MAPF objectives, such as minimizing makespan or minimizing the sum of costs, and for a range of MAPF variants. Moreover, a Picat-based model can be automatically compiled to several general-purpose solvers such as SAT solvers and Mixed Integer Programming solvers (MIP). This is particularly important for MAPF because some MAPF variants are solved more efficiently when compiled to SAT while other variants are solved more efficiently when compiled to MIP. We analyze these differences and the impact of different declarative models and encodings on empirical performance.

The paper presents attribute grammars as a unifying framework for modeling planning domains and problems. The motivation is to exploit techniques from formal languages in domain model verification, plan and goal recognition, domain model acquisition, as well as in planning. Grammar rules are used for action selection while specific set attributes are used to collect events (preconditions and effects of actions) that are ordered using a global timeline constraint. We show how classical STRIPS, hierarchical task networks, and procedural domain models are transformed to attribute grammars.

In the multi-agent path-finding (MAPF) problem a plan is needed to move a set of agents from their initial location to their goals without collisions. In this paper we introduce and study the k-robust MAPF problem, where we seek a plan that is robust to k unexpected delays per agent.

The overall performance of classical planner depends heavily on the domain model which can be enhanced by adding control knowledge and heuristics. Both of them are known techniques which can boost the search process in exchange for some computational overhead needed for their repeated evaluation. Our experiments show that the gain from usage of heuristics and control knowledge is evolving throughout the search process and also depends on the type of search algorithm. We demonstrate the idea using the branch-and-bound and iterative deepening search techniques, both implemented in the Picat planning module.

The multiple-origin-multiple-destination (MOMD) problem is a simplified version of the logistics planning problem in which packages are required to be transported from their origins to their destinations by multiple trucks with a minimum total cost. This paper proves the NP-hardness of the problem and gives two constraint models for solving the problem optimally. These models are then solved by SAT and MIP solvers (after some translation) and the results are experimentally compared with ASP and CP problem encodings.

Many contemporary computer games, notably action and role‐playing games, represent an interesting class of navigation‐intensive dynamic real‐time simulations inhabited by autonomous intelligent virtual agents (IVAs). Although higher level reasoning of IVAs in these domains seems suited for action planning, planning is not widely adopted in existing games and similar applications. Moreover, statistically rigorous study measuring performance of planners in decision making in a game‐like domain is missing. Here, five classical planners were connected to the virtual environment of Unreal Development Kit along with a planner for delete‐free domains (only positive preconditions and positive effects). Performance of IVAs employing those planners and IVAs with reactive architecture was measured on a class of game‐inspired test environments of various sizes and under different levels of external interference. The analysis has shown that planning agents outperform reactive agents if (i) the size of the problem is small or if (b) the environment changes are either hostile to the agent or infrequent. In delete‐free domains, specialized approaches are inferior to classical planners because the lower expressivity of delete‐free domains results in lower plan quality. These results can help to determine when planning is advantageous in games and for IVAs control in other dynamic real‐time environments.

Logic programming provides a declarative framework for modeling and solving many combinatorial problems. Until recently, it was not competitive with state-of-the-art planning techniques partly due to search capabilities limited to backtracking. Recent development brought more advanced search techniques to logic programming such as tabling that simplifies implementation and exploitation of more sophisticated search algorithms. Together with rich modeling capabilities this progress brings tabled logic programing on a par with current best planners. This paper describes the planner module of the tabled logic programming language Picat, its modeling capabilities, and core search procedures behind the planner. The major contribution is an experimental comparison of the influence of various modeling techniques, namely factored vs. structured representations of states, control knowledge, and heuristics on the performance of two search procedures – iterative deepening and branch and bound – behind the planner. The paper also compares the Picat planner with winning automated planners both domain dependent and domain independent to demonstrate that the presented techniques are competitive with state-ofthe- art.

Current research in planning focuses mainly on so called domain independent models using the Planning Domain Description Language (PDDL) as the domain modeling language. This declarative modeling approach embraces the idea of a physics-only model describing how actions change the world. However, PDDL omits information about why and when the actions should be applied to reach the goal, which significantly decreases the practical applicability of PDDL. There exist approaches such as Hierarchical Task Networks (HTN) and control rules that add this type of information to the model with the pay-off of increased efficiency but also with the downside of increased complexity and code sizes.

Solving planning problems via translation to propositional satisfiability (SAT) is one of the most successful approaches to automated planning. An important aspect of this approach is the encoding, i.e., the construction of a propositional formula from a given planning problem instance. Numerous encoding schemes have been proposed in the recent years each aiming to outperform the previous encodings on the majority of the benchmark problems. In this paper we take a different approach. Instead of trying to develop a new encoding that is better for all kinds of benchmarks we take recently developed specialized encoding schemes and design a method to automatically select the proper encoding for a given planning problem instance. In the paper we also examine ranking heuristics for the Relaxed Relaxed Exists-Step encoding, which plays an important role in our algorithm. Experiments show that our new approach significantly outperforms the state-of-the-art encoding schemes when compared on the benchmarks of the 2011 International Planning Competition.

AI Planning is inherently hard and hence it is desirable to derive as much information as we can from the structure of the planning problem and let this information be exploited by a planner. Many recent planners use the finite-domain state-variable representation of the problem instead of the classical propositional representation. However, most planning problems are still specified in the propositional representation due to the widespread modelling language planning domain definition language and it is hard to generate an efficient state-variable representation from the propositional model. In this article, we investigate various methods for automated generation of efficient state-variable representations from the propositional representation and we propose a novel approach – constructed as a combination of existing techniques – that utilises the structural information from the goal and the initial state. We perform an exhaustive experimental evaluation of methods, planning systems and problems, using the International Planning Competition as the main source of data. We show that for many planning problems the novel approach provides an improved efficiency.

Abstract This paper describes Picat's planner, its implementation, and planning models for several domains used in International Planning Competition (IPC) 2014. Picat's planner is implemented by use of tabling. During search, every state encountered is tabled, and tabled states are used to effectively perform resource-bounded search. In Picat, structured data can be used to avoid enumerating all possible permutations of objects, and term sharing is used to avoid duplication of common state data. This paper presents several modeling techniques through the example models, ranging from designing state representations to facilitate data sharing and symmetry breaking, encoding actions with operations for efficient precondition checking and state updating, to incorporating domain knowledge and heuristics. Broadly, this paper demonstrates the effectiveness of tabled logic programming for planning, and argues the importance of modeling despite recent significant progress in domain-independent PDDL planners.

This paper reports on FAPE (Flexible Acting and Planning Environment), a framework integrating acting and planning on the basis of the ANML modeling language. ANML is a recent proposal motivated by combining the expressiveness of the timeline representation with decomposition methods of Hierarchical Task Networks (HTN). Our current focus is not efficient temporal planning per se, but the tight integration of acting and planning. This integration is addressed by: (i) extending HTN methods with the refinement of planned actions with skills, expressed in PRS, to map actions into low-level commands, (ii) interleaving the planning process with acting, the former performs plan repair and replanning, while the latter implements the skill-based refinements, and (iii) executing commands with a dispatching mechanism that synchronizes observed time points of action effects and events with planned time. FAPE has been integrated to a PR2 robot and experimented in a home-like environment. The paper presents how planning is performed and integrated with acting and describes briefly the robotics experiments.

Abstract Tabling has been used for some time to improve efficiency of Prolog programs by memorizing answered queries. The same idea can be naturally used to memorize visited states during search for planning. In this paper we present a planner developed in the Picat language to solve the Petrobras planning problem. Picat is a novel Prolog-like language that provides pattern matching, deterministic and non-deterministic rules, and tabling as its core modelling and solving features. We demonstrate these capabilities using the Petrobras problem, where the goal is to plan transport of cargo items from ports to platforms using vessels with limited capacity. Monte Carlo Tree Search has been so far the best technique to tackle this problem and we will show that by using tabling we can achieve much better runtime efficiency and better plan quality.

There exist planning algorithms that can quickly find sub-optimal plans even for large problems and planning algorithms finding optimal plans but only for smaller problems. In this paper we attempt to integrate both approaches. We present an anytime technique for improving plan quality, in particular for decreasing the plan make span, via substituting parts of the plan by make span-optimal sub-plans. The technique guarantees optimality, though it is primarily intended to quickly improve plan quality. We experimentally compare various approaches to local improvements and we show that our method has significantly better make span score than the SASE planner, which is one of the best optimal planners.

The Petrobras domain is an abstraction of a real-life problem of resource-efficient transportation of goods from ports to petroleum platforms. Being a good example of a difficult problem standing on the borderline between planning and scheduling, this domain was proposed as a challenge problem at the International Competition on Knowledge Engineering for Planning and Scheduling (ICKEPS 2012). In this paper we describe three different ways of modeling and solving this domain: by utilizing classical planning, temporal planning, and finally, single-player games and Monte-Carlo Tree Search.

There exist planning algorithms that can quickly find sub-optimal plans even for large problems and planning algorithms finding optimal plans but only for smaller problems. We attempt to integrate both approaches. We present an anytime technique for improving plan quality (decreasing the plan makespan) via substituting parts of the plan by better sub-plans. The technique guarantees optimality though it is primarily intended to quickly improve plan quality. We experimentally compare various approaches to local improvements.

Inductive Logic Programming (ILP) deals with the problem of finding a hypothesis covering given positive examples and excluding negative examples. It is a sub field of machine learning that uses first-order logic as a uniform representation for examples and hypothesis. In this paper we propose a method to boost given ILP learning algorithm by first decomposing the set of examples to subsets and applying the learning algorithm to each subset separately, second, merging the hypotheses obtained for subsets to get a single hypothesis for the complete set of examples, and finally refining this single hypothesis to make it shorter.

AI Planning typically deals with the causal relations between the actions while the role of explicit time and limited resources is suppressed. The recent trends show that integrating time and resource reasoning into planning significantly improves direct applicability of planning technology in real-life problems. In this paper we propose a suboptimal domain-independent planning system Filuta that focuses on planning, where explicit time plays a major role and resources are constrained. We benchmark Filuta on the planning problems from the International Planning Competition (IPC) 2008 and compare our results with the competition participants.

Planning problems deal with finding a sequence of actions that transfer the initial state of the world into a desired state. Frequently such problems are solved by dedicated algorithms but there exist planners based on translating the planning problem into a different formalism such as constraint satisfaction or Boolean satisfiability and using a general solver for this formalism. The paper describes how to enhance existing constraintmodels of sequential planning problems by using techniques such as symmetry breaking (dominance rules), singleton consistency, nogoods, lifting, or techniques motivated by the partial-order planning.

Efficient data transfers and placements are paramount to optimizing geographically distributed resources and minimizing the time data intensive experiments’s processing tasks would take. We present a technique for planning data transfers to single destination using a Constraint Programming approach. We study enhancements of the model using symmetry breaking, branch cutting, well studied principles from scheduling field, and several heuristics. Real-life wide area network characteristic is explained and the realization of the computed formal schedule is proposed with an emphasis on bandwidth saturation. Results will include comparison of performance and trade-off between CP techniques and Peer-2-Peer model.

Precedence constraints play a crucial role in planning and scheduling problems. Many real-life problems also include dependency constraints expressing logical relations between the activities -- for example, an activity requires presence of another activity in the plan. For such problems a typical objective is a maximization of the number of activities satisfying the precedence and dependency constraints. In the paper we propose new incremental filtering rules integrating propagation through both precedence and dependency constraints. We also propose a new filtering rule using the information about the requested number of activities in the plan. We demonstrate efficiency of the proposed rules on the logbased reconciliation problems and min-cutset problems.