No full-text available
To read the full-text of this research,
you can request a copy directly from the author.
The Fast Downward Planning System
Abstract
Fast Downward is a classical planning system based on heuristic search. It
can deal with general deterministic planning problems encoded in the
propositional fragment of PDDL2.2, including advanced features like ADL
conditions and effects and derived predicates (axioms). Like other well-known
planners such as HSP and FF, Fast Downward is a progression planner, searching
the space of world states of a planning task in the forward direction. However,
unlike other PDDL planning systems, Fast Downward does not use the
propositional PDDL representation of a planning task directly. Instead, the
input is first translated into an alternative representation called
multi-valued planning tasks, which makes many of the implicit constraints of a
propositional planning task explicit. Exploiting this alternative
representation, Fast Downward uses hierarchical decompositions of planning
tasks for computing its heuristic function, called the causal graph heuristic,
which is very different from traditional HSP-like heuristics based on ignoring
negative interactions of operators.
In this article, we give a full account of Fast Downwards approach to solving
multi-valued planning tasks. We extend our earlier discussion of the causal
graph heuristic to tasks involving axioms and conditional effects and present
some novel techniques for search control that are used within Fast Downwards
best-first search algorithm: preferred operators transfer the idea of helpful
actions from local search to global best-first search, deferred evaluation of
heuristic functions mitigates the negative effect of large branching factors on
search performance, and multi-heuristic best-first search combines several
heuristic evaluation functions within a single search algorithm in an
orthogonal way. We also describe efficient data structures for fast state
expansion (successor generators and axiom evaluators) and present a new
non-heuristic search algorithm called focused iterative-broadening search,
which utilizes the information encoded in causal graphs in a novel way.
Fast Downward has proven remarkably successful: It won the "classical (i.e.,
propositional, non-optimising) track of the 4th International Planning
Competition at ICAPS 2004, following in the footsteps of planners such as FF
and LPG. Our experiments show that it also performs very well on the benchmarks
of the earlier planning competitions and provide some insights about the
usefulness of the new search enhancements.
... The task planner uses a language like the Planning Domain Language (PDDL) (Ghallab et al. 1998) to discretise the robot's environment and possible states. Then, the task planner (e.g., Fast Downward (Helmert 2006)) translates this representation into a graph in which every node corresponds to a possible robot's state. The branches between nodes are symbolic actions. ...
... Four experiments are conducted to demonstrate that the proposed task planner outperforms Fast Downward (Helmert 2006), a conventional state-of-the-art task planning algorithm. Indeed, the four experiments prove that the proposed task planner can significantly reduce the task planning time, thus mitigating combinatorial explosion when the number of objects and symbolic locations increases. ...
... The latest approaches in task planning are the heuristic search and constraint-based planners. Fast Forward (Hoffmann 2001) and Fast Downward (Helmert 2006) are the leading Heuristic planners. They construct a search tree from the initial state using a heuristic to guide the search toward the desired final goal state. ...
... The LLM component of LaMMA-P identifies and allocates sub-tasks based on each robot's skills, generates PDDL problem descriptions for each robot's domain, and improves its ability to generalize over human instructions, even when they are vague. These problems are processed by the Fast Downward planner [16] to generate plans for each robot's assigned sub-task. If the initial plan fails, the LLM regenerates and adapts the plan until a viable solution is produced. ...
... The first step in our framework involves decomposing the task into sub-tasks [11] and introducing a Precondition Identifier for each one. Classical planner computes a heuristic h(I, G) by ignoring delete effects [16], whereas LLMs tackle tasks through probabilistic reasoning over action sequences . **PickupObject**: Robot picks up the egg. ...
... where only add effects of the actions taken are considered [16]. The heuristic h(I, G) estimates the cost of reaching the goal state G from the initial state I, and the function cost(a) is the cost of performing action a. Π represents a valid action sequence, and the minimization is taken over all valid action sequences Π(I, G). ...
Language models (LMs) possess a strong capability to comprehend natural language, making them effective in translating human instructions into detailed plans for simple robot tasks. Nevertheless, it remains a significant challenge to handle long-horizon tasks, especially in subtask identification and allocation for cooperative heterogeneous robot teams. To address this issue, we propose a Language Model-Driven Multi-Agent PDDL Planner (LaMMA-P), a novel multi-agent task planning framework that achieves state-of-the-art performance on long-horizon tasks. LaMMA-P integrates the strengths of the LMs' reasoning capability and the traditional heuristic search planner to achieve a high success rate and efficiency while demonstrating strong generalization across tasks. Additionally, we create MAT-THOR, a comprehensive benchmark that features household tasks with two different levels of complexity based on the AI2-THOR environment. The experimental results demonstrate that LaMMA-P achieves a 105% higher success rate and 36% higher efficiency than existing LM-based multi-agent planners. The experimental videos, code, and datasets of this work as well as the detailed prompts used in each module are available at https://lamma-p.github.io.
... Such use of symbolic language in robotic task planning is traced back to the Shakey robot project in the early 1970s using STRIPS [2]. However, since the time complexity of these symbolic planners is known to be PSPACE-hard [3], solving long-sequential tasks in domains with extensive search spaces using these symbolic planners is intractable, making their practical application to robot task planning limited. Recently, Large Language Models (LLMs) have shown advantages as autonomous robot task planners due to the short inference time compared to symbolic planners and their ability to leverage commonsense knowledge and generalization capabilities [4]. ...
... We conducted experiments using a commercial LLM model across three task planning domains while varying the problem complexity. Compared to the state-of-the-art symbolic task planner, such as the fast-downward planner [3], our approach significantly reduced planning time while maintaining an acceptable success rate. Additionally, we conducted experiments using dual robot manipulators as well as using a robotic simulator to demonstrate the practical utility of our planner. ...
... We formulate our task planning problem as a multi-valued planning task (MPT) [3] using a tuple: ...
In robotic task planning, symbolic planners using rule-based representations like PDDL are effective but struggle with long-sequential tasks in complicated planning environments due to exponentially increasing search space. Recently, Large Language Models (LLMs) based on artificial neural networks have emerged as promising alternatives for autonomous robot task planning, offering faster inference and leveraging commonsense knowledge. However, they typically suffer from lower success rates. In this paper, to address the limitations of the current symbolic (slow speed) or LLM-based approaches (low accuracy), we propose a novel neuro-symbolic task planner that decomposes complex tasks into subgoals using LLM and carries out task planning for each subgoal using either symbolic or MCTS-based LLM planners, depending on the subgoal complexity. Generating subgoals helps reduce planning time and improve success rates by narrowing the overall search space and enabling LLMs to focus on smaller, more manageable tasks. Our method significantly reduces planning time while maintaining a competitive success rate, as demonstrated through experiments in different public task planning domains, as well as real-world and simulated robotics environments.
... Much previous work has investigated the action selection problem posed above [8,9,10,11,15]. At a high level, previously proposed algorithms often reason over the broad space of which actions are viable at a certain state. ...
... For instance, if there are many viable actions that beget many viable actions to consider at a next step, and so on, the number of possible action branches scale exponentially with respect to the number of planning steps, often overwhelming computational resources. While heuristics can help alleviate this issue [9,11], it may still be Fig. 1: We present a strategy that frames action selection in terms of resolving blocking conditions, i.e., situations that impede progress on an action en route to a goal. ...
... Over the years, several highly efficient task planning algorithms have been developed to find feasible sequences of actions from start to goal, including Fast Forward (FF) [11] and Fast Downward (FD) [9]. FF uses a graph search strategy coupled with a carefully designed heuristic that estimates the cost to reach the goal from the current state. ...
In this work, we introduce a strategy that frames the sequential action selection problem for robots in terms of resolving \textit{blocking conditions}, i.e., situations that impede progress on an action en route to a goal. This strategy allows a robot to make one-at-a-time decisions that take in pertinent contextual information and swiftly adapt and react to current situations. We present a first instantiation of this strategy that combines a state-transition graph and a zero-shot Large Language Model (LLM). The state-transition graph tracks which previously attempted actions are currently blocked and which candidate actions may resolve existing blocking conditions. This information from the state-transition graph is used to automatically generate a prompt for the LLM, which then uses the given context and set of possible actions to select a single action to try next. This selection process is iterative, with each chosen and executed action further refining the state-transition graph, continuing until the agent either fulfills the goal or encounters a termination condition. We demonstrate the effectiveness of our approach by comparing it to various LLM and traditional task-planning methods in a testbed of simulation experiments. We discuss the implications of our work based on our results.
... For example, a "place" skill can be initiated when the robot is holding an object and facing a surface; the skill terminates after the robot opens its gripper; and the skill is successful if the object is subsequently stably resting on the surface. Options are closely related to AI planning operators [33,53] and we can leverage this relationship to efficiently plan a sequence of skills to reach a goal [28]. ...
... situating the competence in the task distribution by predicting how overall task success rates would hypothetically improve. We propose a Beta-Bernoulli time series model to estimate and extrapolate skill competence and use cost-aware AI planning [28] to situate the competence in the task distribution. ...
... Previous work has considered how to learn these operators automatically; we manually specify them for this work. To satisfy condition (1), we associate a cost of log(c) to the respective operator and use an off-the-shelf AI planner [28] to find a minimal cost (maximum likelihood) skeleton. See Appendix A for further details. ...
... operators together form a PDDL domain [17], enabling a planning algorithm to generate plans for arbitrary in-domain tasks [18]. Despite the wide adoptions of planning algorithms in robotics [19,20,21], these methods usually require substantial manual effort and domain expertise to meticulously design the predicates and operators, hindering their applicability to real-world problems. ...
... The learned predicates and operators can be compiled into a PDDL domain. By converting a language goal g P G into a symbolic goal s g [11,62], such a PDDL domain can enable effective planning using an off-the-shelf classical planner [18]. ...
... During the training phase, InterPreT learns predicates and operators as the robot interacts with the environment to perform a series of training tasks (detailed in Section V-A3). We employ a strategy where the robot plans with a classical planner [18] based on the learned predicates and operators 50% of the time, and randomly takes a symbolically feasible action according to the recorded action preconditions otherwise. Empirically, this approach enables a balance between exploration and exploitation. ...
... The ability to plan is crucial for embodied agents and robotic systems because these sys-tems must break down high-level goals into a sequence of low-level, admissible actions to function effectively. Classical algorithms, such as Fast-Downward (Helmert, 2006), can handle problems defined in PDDL, but many real-world applications are less ideal. Several issues arise, including goals that may be ambiguously expressed in natural language, environments that may only be partially observable, and state transition functions that may not be well-defined and are non-deterministic. ...
... However, some researchers argued that LLMs in their current states are fundamentally weak at planning. So, many have also proposed using algorithms such as Fast-Downward (Helmert, 2006) and even separately trained models to perform planning . We argue that the exploration of plan generators, especially non-LLM based planners, are far from an end. ...
... LLM+P (Liu et al., 2023a), for example, employs a 3 step process. The LLM first takes a natural language description of a planning problem and translates it into a PDDL file, which is fed into a classical planner such as Fast-Downward (Helmert, 2006). After the problem is solved using the planner, LLM translates the solution back in natural language for interpretability. ...
Effective planning is essential for the success of any task, from organizing a vacation to routing autonomous vehicles and developing corporate strategies. It involves setting goals, formulating plans, and allocating resources to achieve them. LLMs are particularly well-suited for automated planning due to their strong capabilities in commonsense reasoning. They can deduce a sequence of actions needed to achieve a goal from a given state and identify an effective course of action. However, it is frequently observed that plans generated through direct prompting often fail upon execution. Our survey aims to highlight the existing challenges in planning with language models, focusing on key areas such as embodied environments, optimal scheduling, competitive and cooperative games, task decomposition, reasoning, and planning. Through this study, we explore how LLMs transform AI planning and provide unique insights into the future of LM-assisted planning.
... Planning tasks are encoded into the SAS+ model on the Fast Downward planning system (Helmert 2006). An SAS+ planning task is defined by a 4-tuple Π = ⟨V, O, s 0 , s * ⟩ (Bäckström and Nebel 1995 ...
... Both CPC0 and CPC1 are built upon an early 2017 fork of the Fast Downward planning system (Helmert 2006) with the h 2 -based pre-processor to remove irrelevant operators (Alcázar and Torralba 2015). The symbolic search is enhanced with the techniques proposed by . ...
Pattern database (PDB) is one of the most popular automated heuristic generation techniques. A PDB maps states in a planning task to abstract states by considering a subset of variables and stores their optimal costs to the abstract goal in a look up table. As the result of the progress made on symbolic search over recent years, symbolic-PDB-based planners achieved impressive results in the International Planning Competition (IPC) 2018. Among them, Complementary 1 (CPC1) tied as the second best planners and the best non-portfolio planners in the cost optimal track, only 2 tasks behind the winner. It uses a combination of different pattern generation algorithms to construct PDBs that are complementary to existing ones. As shown in the post contest experiments, there is room for improvement. In this paper, we would like to present our work on refining the PDB construction mechanism of CPC1. By testing on IPC 2018 benchmarks, the results show that a significant improvement is made on our modified planner over the original version.
... Second, the uncertainty of obtaining the reward is typically ignored. Although handling uncertainty in planning systems seems necessary in dynamic environments, most existing research on underwater mission planning (e.g., on re-planning [2], [3] or temporal planning [4]) defines planning problems as optimization against the mean reward objective such as time or energy [5]. ...
... We created the scenarios for gas and oil infrastructure inspection by using public assets from the DAVE project. 3 The 3D models can be obtained from the TurboSquid website. 4 We estimate the occupancy probability for the discretized (high-level) map using OctoMap [17], calculating the probability that a section of the environment is occupied using simulated forward multibeam p900 sonar data. ...
Autonomous Underwater Vehicles (AUVs) need to operate for days without human intervention and thus must be able to do efficient and reliable task planning. Unfortunately, efficient task planning requires deliberately abstract domain models (for scalability reasons), which in practice leads to plans that might be unreliable or under performing in practice. An optimal abstract plan may turn out suboptimal or unreliable during physical execution. To overcome this, we introduce a method that first generates a selection of diverse high-level plans and then assesses them in a low-level simulation to select the optimal and most reliable candidate. We evaluate the method using a realistic underwater robot simulation, estimating the risk metrics for different scenarios, demonstrating feasibility and effectiveness of the approach.
... In fact, for many models it seems to do significantly worse! 5 This is most notable in our tests of LLaMA family models. [8] solves all given instances near-instantly with guaranteed perfect accuracy. LLMs struggle on even the smallest instances. ...
... Classical planners like Fast Downward [8] achieve 100% on our dataset in a fraction of the time, compute, and cost, while providing guarantees that their answers are correct. Running Fast Downward on a personal computer was essentially free in dollar terms and averaged 0.265 seconds per instance, which is many orders of magnitude faster than the average o1 clock times listed in table 2. It is also generally predictable, and can be scaled to harder instances very directly. ...
The ability to plan a course of action that achieves a desired state of affairs has long been considered a core competence of intelligent agents and has been an integral part of AI research since its inception. With the advent of large language models (LLMs), there has been considerable interest in the question of whether or not they possess such planning abilities. PlanBench, an extensible benchmark we developed in 2022, soon after the release of GPT3, has remained an important tool for evaluating the planning abilities of LLMs. Despite the slew of new private and open source LLMs since GPT3, progress on this benchmark has been surprisingly slow. OpenAI claims that their recent o1 (Strawberry) model has been specifically constructed and trained to escape the normal limitations of autoregressive LLMs--making it a new kind of model: a Large Reasoning Model (LRM). Using this development as a catalyst, this paper takes a comprehensive look at how well current LLMs and new LRMs do on PlanBench. As we shall see, while o1's performance is a quantum improvement on the benchmark, outpacing the competition, it is still far from saturating it. This improvement also brings to the fore questions about accuracy, efficiency, and guarantees which must be considered before deploying such systems.
... This information is used in motion-level planning to derive collision-free trajectories (if one exists for a given task plan action). In addition to Chat-GPT 1 [21] as our LLM of choice, we use Fast Downward [27], an off-the-shelf PDDL solver, for task-level planning in our method as well as baselines (discussed in Section V-B). When planning with Fast Downward, we use the A* algorithm with the landmark cut (LMCUT) heuristic for plan optimality. ...
... As input to the LLM, we provide a description of the robot's environment (s) and an example of a problem definition task, and we obtain a problem definition as output. We then use this output with our domain definition of predefined skills to acquire a task plan using Fast Downward [27], and this task plan is executed and resolved with motion-level planning. This baseline approach evaluates the LLM's ability to accurately generate a PDDL problem file, compatible with a predefined set of skills, without explicitly performing object-level planning and reasoning. ...
We introduce a new method that extracts knowledge from a large language model (LLM) to produce object-level plans, which describe high-level changes to object state, and uses them to bootstrap task and motion planning (TAMP) in a hierarchical manner. Existing works use LLMs to either directly output task plans or to generate goals in representations like PDDL. However, these methods fall short because they either rely on the LLM to do the actual planning or output a hard-to-satisfy goal. Our approach instead extracts knowledge from a LLM in the form of plan schemas as an object level representation called functional object-oriented networks (FOON), from which we automatically generate PDDL subgoals. Our experiments demonstrate how our method's performance markedly exceeds alternative planning strategies across several tasks in simulation.
... II. RELATED WORK The problem of Task Planning (TP) has been extensively studied. Traditionally, planning problems are represented using languages like STRIPS [11] or PDDL [12] and solved with tree search methods [1]- [3]. In robotics, these methods have evolved to handle continuous variables and geometric information, leading to Task and Motion Planning (TAMP) [13]- [15]. ...
... 1) Search-based Policies: These policies are derived from a solution to a search problem, given an initial condition S 0 and a set of goal states G, e.g., Fast Downward [3] or MCTS [17]. This solution is a planã = (a 0 , . . . ...
Planning methods struggle with computational intractability in solving task-level problems in large-scale environments. This work explores leveraging the commonsense knowledge encoded in LLMs to empower planning techniques to deal with these complex scenarios. We achieve this by efficiently using LLMs to prune irrelevant components from the planning problem's state space, substantially simplifying its complexity. We demonstrate the efficacy of this system through extensive experiments within a household simulation environment, alongside real-world validation using a 7-DoF manipulator (video https://youtu.be/6ro2UOtOQS4).
... best ← d NL {Initialize with an empty template}. 5: 8: f (c) ← Natural language feedback from EW on d, p. 9: ...
... (2) with T max = 10). We use the original fast-downward [9] library for planning, the modified fast-downward library from text-world [5] for python-compatible state explorations, and the VAL [10] library to validate plans. ...
Large Language Models (LLMs) have shown remarkable performance in various natural language tasks, but they often struggle with planning problems that require structured reasoning. To address this limitation, the conversion of planning problems into the Planning Domain Definition Language (PDDL) has been proposed as a potential solution, enabling the use of automated planners. However, generating accurate PDDL files typically demands human inputs or correction, which can be time-consuming and costly. In this paper, we propose a novel approach that leverages LLMs and environment feedback to automatically generate PDDL domain and problem description files without the need for human intervention. Our method introduces an iterative refinement process that generates multiple problem PDDL candidates and progressively refines the domain PDDL based on feedback obtained from interacting with the environment. To guide the refinement process, we develop an Exploration Walk (EW) metric, which provides rich feedback signals for LLMs to update the PDDL file. We evaluate our approach on PDDL environments. We achieve an average task solve rate of 66% compared to a 29% solve rate by GPT-4's intrinsic planning with chain-of-thought prompting. Our work enables the automated modeling of planning environments using LLMs and environment feedback, eliminating the need for human intervention in the PDDL generation process and paving the way for more reliable LLM agents in challenging problems.
... For example, constraint 1 ExclusiveChoice(c, d) (C1 for short in the tables) has 38 traces (out of the 50 negative ones) violating it of which 19 require 1 alignment, 13 require 2 alignments, and 6 require 3 or more alignments, for a total of 68 alignments. The costs are computed by compiling the problem into the Planning Domain Definition Language [9] and solving it with Fast Downward [24]. To better understand the noise of the log, in Table 3 we report, for each trace length, the number of alignments required to make the traces of that length conformant with the constraint. ...
In this work, we present a novel approach to learning Linear Temporal Logic (LTL) formulae from event logs by leveraging statistical techniques from sequential analysis. In particular, we employ the Sequential Probability Ratio Test (SPRT), using Trace Alignment to quantify the discrepancy between a trace and a candidate LTL formula. We then test the proposed approach in a controlled experimental setting and highlight its advantages, which include robustness to noise and data efficiency.
... We compute the immediate plan cost via FastDownward [19] using informed search with the ff-astar heuristic [21] and use a GNN, in particular via a representation based on 3D scene graph to estimate the anticipatory cost. We ...
We consider the setting where a robot must complete a sequence of tasks in a persistent large-scale environment, given one at a time. Existing task planners often operate myopically, focusing solely on immediate goals without considering the impact of current actions on future tasks. Anticipatory planning, which reduces the joint objective of the immediate planning cost of the current task and the expected cost associated with future subsequent tasks, offers an approach for improving long-lived task planning. However, applying anticipatory planning in large-scale environments presents significant challenges due to the sheer number of assets involved, which strains the scalability of learning and planning. In this research, we introduce a model-based anticipatory task planning framework designed to scale to large-scale realistic environments. Our framework uses a GNN in particular via a representation inspired by a 3D Scene Graph to learn the essential properties of the environment crucial to estimating the state's expected cost and a sampling-based procedure for practical large-scale anticipatory planning. Our experimental results show that our planner reduces the cost of task sequence by 5.38% in home and 31.5% in restaurant settings. If given time to prepare in advance using our model reduces task sequence costs by 40.6% and 42.5%, respectively.
... The Fast Downward planner is also a notable instance of successful abstraction, both in translating propositional planning problems into a multi-value representation that captures implicit dynamics in the problem, and for performing partial hierarchical decomposition for the causal graph heuristic (Helmert 2006). Our method draws some inspiration from Fast Downward and develops a representation of the problem that captures the implicit dynamics present in a low-level multi-value planning problem, but the similarity is only in concept and not method. ...
Contemporary automated planning research emphasizes the use of domain knowledge abstractions like heuristics to improve search efficiency. Transformative automated abstraction techniques which decompose or otherwise reformulate the problem have a limited presence, owing to poor performance in key metrics like plan length and time efficiency. In this paper, we argue for a reexamination of these transformative techniques in the context of narrative planning, where classical metrics are less appropriate. We propose a model for automating abstraction by decomposing a planning problem into subproblems which serve as abstract features of the problem. We demonstrate the application of this approach on a low-level problem and discuss key features of the resulting abstract problem. Plans in the abstract problem are shorter, representing summaries of low-level plans, but can be directly translated into low-level plans for the original problem.
... Instead, we first ground the set of reachable actions and literals before prompting the VLM to return values in these sets. We use relaxed planning [42,43] from the initial state s 0 to simultaneously ground [44,45,46] and explore the sets of reachable actions A and literals L. When instantiating continuous parameters, we use placeholder values, such as optimistic values [47,48,9,49], to ensure a finite set of actions are instantiated. Similarly, we use placeholders for description parameters. ...
Foundation models trained on internet-scale data, such as Vision-Language Models (VLMs), excel at performing tasks involving common sense, such as visual question answering. Despite their impressive capabilities, these models cannot currently be directly applied to challenging robot manipulation problems that require complex and precise continuous reasoning. Task and Motion Planning (TAMP) systems can control high-dimensional continuous systems over long horizons through combining traditional primitive robot operations. However, these systems require detailed model of how the robot can impact its environment, preventing them from directly interpreting and addressing novel human objectives, for example, an arbitrary natural language goal. We propose deploying VLMs within TAMP systems by having them generate discrete and continuous language-parameterized constraints that enable TAMP to reason about open-world concepts. Specifically, we propose algorithms for VLM partial planning that constrain a TAMP system's discrete temporal search and VLM continuous constraints interpretation to augment the traditional manipulation constraints that TAMP systems seek to satisfy. We demonstrate our approach on two robot embodiments, including a real world robot, across several manipulation tasks, where the desired objectives are conveyed solely through language.
... Section VI-B). The classical planning approach is implemented by leveraging the Fast Downward planner [60], which supports PDDL 2.2 with cost actions [61]. The MDP-based approaches are implemented using the MDP-DP-RL library 5 . ...
In recent decades, manufacturing practices have undergone a significant transformation, with the integration of computers and automation playing a central role. Concurrently, there has been a growing interest in utilizing intelligent techniques to effectively manage manufacturing processes. These processes entail the seamless integration of various activities across the supply chain. Given the diverse range of actors in a supply chain, each one with distinct characteristics such as cost, quality, and probability of failure, task assignment becomes a crucial challenge. In such a complex scenario, manual decision-making becomes impractical, necessitating the adoption of automated techniques to effectively address these challenges in a resilient and adaptive manner. This paper proposes a service-oriented approach to model each manufacturing actor within the supply chain. Furthermore, it categorizes automated synthesis approaches for smart manufacturing on the basis of
(i)
the characteristics of each actor, which are retrieved by their Industrial API, and
(ii)
the goal(s) of the manufacturing process. Finally, the paper evaluates three distinct approaches that implement automated synthesis techniques for composing services and generating operational plans
... Due to its widespread use in the robotics community, including in the popular Robot Operating System (ROS) [80], we selected the Planning Domain Definition Language (PDDL) [44] as the language for the robot to describe, reason, and plan about its own ToM. Specifically, we refer to the subset of PDDL used, among others, by the Fast Downward planner [58]. Here, we assume basic knowledge of PDDL. ...
The objective of this work is to develop and evaluate computational cognitive models of Theory of Mind (ToM) and Machiavellian behavior embedded in a humanoid robot. Machiavellianism, together with psychopathy and narcissism, is part of the Dark Triad (DT), three constructs that correspond to socially aversive yet not necessarily pathological personalities. The motivations of the present work are both theoretical and application-oriented. In the long term, we aim to: (i) Provide researchers with new insights into the Machiavellian as well as other DT constructs through simulated and robotic setups; (ii) Provide a tool to train psychologists to deal with social and antisocial behavior in a controlled setup; (iii) Help people become aware of the behavioral mechanisms that they may expect from people with DT traits in social and affective relationships; (iv) Assist robotic engineers in developing better robots by identifying behaviors that should be avoided. To this end, we explored a computational model of ToM in the popular Planning Domain Definition Language (PDDL), and defined a domain with the necessary elements to induce Machiavellian behavior during planning and execution. Subsequently, we implemented our computational model in a software architecture controlling the behavior of a humanoid robot and recorded videos of the robot interacting with two actors. Finally, we conducted experiments with 300 participants divided into 6 conditions to verify whether the implemented framework is versatile enough to generate behaviors that participants would rate as either more Machiavellian or less Machiavellian based on their observations of the recorded videos.
... PDDL Symbolic planner -To generate the plan trace for a given problem, we make use of the FastDownward symbolic planning framework [33] in this study. FastDownward (FD) takes as input the domain and problem PDDL files generated for a specific problem and outputs a plan trace for execution. ...
Intelligent and reliable task planning is a core capability for generalized robotics, requiring a descriptive domain representation that sufficiently models all object and state information for the scene. We present CLIMB, a continual learning framework for robot task planning that leverages foundation models and execution feedback to guide domain model construction. CLIMB can build a model from a natural language description, learn non-obvious predicates while solving tasks, and store that information for future problems. We demonstrate the ability of CLIMB to improve performance in common planning environments compared to baseline methods. We also develop the BlocksWorld++ domain, a simulated environment with an easily usable real counterpart, together with a curriculum of tasks with progressing difficulty for evaluating continual learning. Additional details and demonstrations for this system can be found at https://plan-with-climb.github.io/ .
... Our work adheres to the sequence-before-satisfy approach [6,7,8,9,10,11,12,13], often leveraging AI heuristics, such as Fast Downward [70], to efficiently find plan skeletons initially without considering continuous typed variables. The search for plan skeletons is then followed by finding satisfying values for the typed variables. ...
In robot planning, tasks can often be achieved through multiple options, each consisting of several actions. This work specifically addresses deadline constraints in task and motion planning, aiming to find a plan that can be executed within the deadline despite uncertain planning and execution times. We propose an effort allocation problem, formulated as a Markov decision process (MDP), to find such a plan by leveraging metareasoning perspectives to allocate computational resources among the given options. We formally prove the NP-hardness of the problem by reducing it from the knapsack problem. Both a model-based approach, where transition models are learned from past experience, and a model-free approach, which overcomes the unavailability of prior data acquisition through reinforcement learning, are explored. For the model-based approach, we investigate Monte Carlo tree search (MCTS) to approximately solve the proposed MDP and further design heuristic schemes to tackle NP-hardness, leading to the approximate yet efficient algorithm called DP_Rerun. In experiments, DP_Rerun demonstrates promising performance comparable to MCTS while requiring negligible computation time.
... Given a task (Section 2), we use the initial state x 0 and a goal G, we construct a PDDL planning problem with initial state ABSTRACT(x 0 ) and use a PDDL planner [33] to efficiently generate a sequence of planning operators (a skeleton) that chain together by precondition and effect to reach the goal. In experiments, we perform A * search using the LM-Cut heuristic. ...
The real world is unpredictable. Therefore, to solve long-horizon decision-making problems with autonomous robots, we must construct agents that are capable of adapting to changes in the environment during deployment. Model-based planning approaches can enable robots to solve complex, long-horizon tasks in a variety of environments. However, such approaches tend to be brittle when deployed into an environment featuring a novel situation that their underlying model does not account for. In this work, we propose to learn a ``bridge policy'' via Reinforcement Learning (RL) to adapt to such novelties. We introduce a simple formulation for such learning, where the RL problem is constructed with a special ``CallPlanner'' action that terminates the bridge policy and hands control of the agent back to the planner. This allows the RL policy to learn the set of states in which querying the planner and following the returned plan will achieve the goal. We show that this formulation enables the agent to rapidly learn by leveraging the planner's knowledge to avoid challenging long-horizon exploration caused by sparse reward. In experiments across three different simulated domains of varying complexity, we demonstrate that our approach is able to learn policies that adapt to novelty more efficiently than several baselines, including a pure RL baseline. We also demonstrate that the learned bridge policy is generalizable in that it can be combined with the planner to enable the agent to solve more complex tasks with multiple instances of the encountered novelty.
... Prior works can be roughly classified into three categories: classic logic-based, learning-based, and LLMs-based. Classic logic-based methods [9], [10], [11], [12], primarily utilizing Planning Domain Description Language (PDDL) [9], leverage predicate logic solvers for task planning. However, these methods are unsuitable for large-scale open world and unknown environment exploration. ...
Leveraging the powerful reasoning capabilities of large language models (LLMs), recent LLM-based robot task planning methods yield promising results. However, they mainly focus on single or multiple homogeneous robots on simple tasks. Practically, complex long-horizon tasks always require collaborations among multiple heterogeneous robots especially with more complex action spaces, which makes these tasks more challenging. To this end, we propose COHERENT, a novel LLM-based task planning framework for collaboration of heterogeneous multi-robot systems including quadrotors, robotic dogs, and robotic arms. Specifically, a Proposal-Execution-Feedback-Adjustment (PEFA) mechanism is designed to decompose and assign actions for individual robots, where a centralized task assigner makes a task planning proposal to decompose the complex task into subtasks, and then assigns subtasks to robot executors. Each robot executor selects a feasible action to implement the assigned subtask and reports self-reflection feedback to the task assigner for plan adjustment. The PEFA loops until the task is completed. Moreover, we create a challenging heterogeneous multi-robot task planning benchmark encompassing 100 complex long-horizon tasks. The experimental results show that our work surpasses the previous methods by a large margin in terms of success rate and execution efficiency. The experimental videos, code, and benchmark are released at https://github.com/MrKeee/COHERENT.
... Several representative heuristic functions have been identified, including the Additive/Max Heuristic [58], Heuristic Based on Relaxed Plan Solution [59], Causal Graph Heuristic [60], and Landmarks Heuristic [61]. Heuristic searchbased planning systems, such as Fast-Forward (FF) [59], Fast Downward [62], SGPlan [63], and LAMA [64], have frequently won the International Planning Competition and have become mainstream in current intelligent planning research. In addition, combinatorial optimization algorithms are widely used in heuristic planning, such as simulated annealing, genetic algorithms, particle swarm optimization, and ant colony optimization. ...
Penetration Testing (PT) is an effective proactive security technique that simulates hacker attacks to identify vulnerabilities in networks or systems. However, traditional PT relies on specialized experience and costs extraordinary time and effort. With the advancement of artificial intelligence technologies, automated PT has emerged as a promising solution, attracting attention from researchers increasingly. In automated PT, penetration path planning is a core task that involves selecting the optimal attack paths to maximize the overall efficiency and success rate of the testing process. Recent years have seen significant progress in the field of penetration path planning, with diverse methods being proposed. This survey aims to comprehensively examine and summarize the research findings in this domain. Our work first outlines the background and challenges of penetration path planning and establishes the framework for research methods. It then provides a detailed analysis of existing studies from three key aspects: penetration path planning models, penetration path planning methods, and simulation environments. Finally, this survey offers insights into the future development trends of penetration path planning in PT. This paper aims to provide comprehensive references for academia and industry, promoting further research and application of automated PT path planning methods.
... II. RELATED WORK Classical Planning in Robotics: Classical planning relies on symbolic representations, with PDDL [1] being the most widely used domain language. It generates action sequences for small-scale, well-defined problems, leveraging search algorithms to reach the goal state from the initial state under the closed-world assumption [14]- [16]. Researchers have also tried to combine discrete symbolic space planning with continuous geometric space sampling [17], [18]. ...
Robotic assembly tasks are open challenges due to the long task horizon and complex part relations. Behavior trees (BTs) are increasingly used in robot task planning for their modularity and flexibility, but manually designing them can be effort-intensive. Large language models (LLMs) have recently been applied in robotic task planning for generating action sequences, but their ability to generate BTs has not been fully investigated. To this end, We propose LLM as BT-planner, a novel framework to leverage LLMs for BT generation in robotic assembly task planning and execution. Four in-context learning methods are introduced to utilize the natural language processing and inference capabilities of LLMs to produce task plans in BT format, reducing manual effort and ensuring robustness and comprehensibility. We also evaluate the performance of fine-tuned, fewer-parameter LLMs on the same tasks. Experiments in simulated and real-world settings show that our framework enhances LLMs' performance in BT generation, improving success rates in BT generation through in-context learning and supervised fine-tuning.
... [43]. We also used the Fast Downward 23.06 [44] planner with the blind search A * heuristic and SymK (rev. c97ce836a) [45] with the default configuration. ...
We study a planning problem based on Plotting, a tile-matching puzzle video game published by Taito in 1989. The objective of this turn-based game is to remove a target number of coloured blocks from a grid by sequentially shooting blocks into the same grid. Plotting features complex transitions after every shot: various blocks are affected directly, while others can be indirectly affected by gravity. We consider modelling and solving Plotting from two perspectives. The puzzle is naturally cast as an AI Planning problem and we first discuss modelling the problem using the Planning Domain Definition Language (PDDL). We find that a model in which planning actions correspond to player actions is inefficient with a grounding-based state-of-the-art planner. However, with a more fine-grained action model, where each change of a block is a planning action, solving performance is dramatically improved. We also describe two lifted constraint models, able to capture the inherent complexities of Plotting and enabling the application of efficient solving approaches from SAT and CP. Our empirical results with these models demonstrates that they can compete with, and often exceed, the performance of the dedicated planning solvers, suggesting that the richer languages available to constraint modelling can be of benefit when considering planning problems with complex changes of state. CP and SAT solvers solved almost all of the largest and most challenging instances within 1 hour, whereas the best planning approach solved approximately 30%. Finally, the flexibility provided by the constraint models allows us to easily curate interesting levels for human players.
... Task planning aims to determine the sequence of actions that a robot should perform to achieve a specific goal. Conventional methods transfer this planning problem to a search problem via symbolic planners [6,7]. They define the planning problem in a declarative language, such as planning domain definition language (PDDL) [1,4], specifying the initial state, goal, and a set of actions that the robot can take to transition between states. ...
... Exploration was simulated by changing the robot's location and adding all objects designated to the explored location to the robot's memory. We use Fast Downward [18] as the planner with a time limit of 300 seconds. ...
... Our algorithm uses Fast Downward [46] planner to solve deterministic planning problems during model learning. The input to Fast Downward is a problem file describing the initially true atoms in PDDL and a domain model describing the deterministic transition model in terms of a set of action schema. ...
... Before specifically analysing each scenario, one thing is to be noted, and that is the planning configuration used to output a plan. The planning system used is based on the Fast-Downward [10] framework, more notably the LAMA-first planning system. This planning system aims to heuristically solve a search problem using a greedy approach, based on best first search. ...
We propose a solution for handling abort commands given to robots. The solution is exemplified with a running scenario with household kitchen robots. The robot uses planning to find sequences of actions that must be performed in order to gracefully cancel a previously received command. The Planning Domain Definition Language (PDDL) is used to write a domain to model kitchen activities and behaviours, and this domain is enriched with knowledge from online ontologies and knowledge graphs, like DBPedia. We discuss the results obtained in different scenarios.
... We implemented all proposed planners in C++, using LAPKT's [21] planning modules. For hybrid experiments, LAMA-First [23] and Scorpion-Maidu [3,26] served as backend components, employing Fast-Downward [10] and the IPC2023 code repository [4], respectively. Except for Approximate-BFWS, BFWS variants utilized the FD-grounder for grounding [11], however in problems where the FD grounder produces axioms (unsupported by LAPKT), LAPKT automatically switched to the Tarski grounder [7]. ...
Count-based exploration methods are widely employed to improve the exploratory behavior of learning agents over sequential decision problems. Meanwhile, Novelty search has achieved success in Classical Planning through recording of the first, but not successive, occurrences of tuples. In order to structure the exploration, however, the number of tuples considered needs to grow exponentially as the search progresses. We propose a new novelty technique, classical count-based novelty, which aims to explore the state space with a constant number of tuples, by leveraging the frequency of each tuple's appearance in a search tree. We then justify the mechanisms through which lower tuple counts lead the search towards novel tuples. We also introduce algorithmic contributions in the form of a trimmed open list that maintains a constant size by pruning nodes with bad novelty values. These techniques are shown to complement existing novelty heuristics when integrated in a classical solver, achieving competitive results in challenging benchmarks from recent International Planning Competitions. Moreover, adapting our solver as the frontend planner in dual configurations that utilize both memory and time thresholds demonstrates a significant increase in instance coverage, surpassing current state-of-the-art solvers.
... Data We use the collection of PDDL problem instances from the International Planning Competition (IPC) 2008. Out of these instances, we select a subset that can be solved relatively quickly by using the blind search configuration of the efficient planner Fast Downward (Helmert 2006) and choose the instances that were solved in under 5 seconds. This resulted in 11 instances. ...
Planning remains one of the last standing bastions for large language models (LLMs), which now turn their attention to search. Most of the literature uses the language models as world models to define the search space, forgoing soundness for the sake of flexibility. A recent work, Thought of Search (ToS), proposed defining the search space with code, having the language models produce that code. ToS requires a human in the loop, collaboratively producing a sound successor function and goal test. The result, however, is worth the effort: all the tested datasets were solved with 100% accuracy. At the same time LLMs have demonstrated significant progress in code generation and refinement for complex reasoning tasks. In this work, we automate ToS (AutoToS), completely taking the human out of the loop of solving planning problems. AutoToS guides the language model step by step towards the generation of sound and complete search components, through feedback from both generic and domain specific unit tests. We achieve 100% accuracy, with minimal feedback iterations, using LLMs of various sizes on all evaluated domains.
... We compare LACFIP k against BASELINE, an algorithm that assigns either (i) the minimum cost (1) to all the actions when solving CFL tasks; or (ii) the cost prescribed by the approximate cost function when solving CFLC . Both algorithms have been implemented in Python, and leverage FAST DOWN-WARD (Helmert 2006) translator to get the grounded actions of a planning task. Experiments were run on AMD EPYC 7R13 CPUs @ 3.6Ghz with a 8GB memory bound and a total time limit of 1 800s per algorithm and cost function learning task. ...
Most of the work on learning action models focus on learning the actions' dynamics from input plans. This allows us to specify the valid plans of a planning task. However, very little work focuses on learning action costs, which in turn allows us to rank the different plans. In this paper we introduce a new problem: that of learning the costs of a set of actions such that a set of input plans are optimal under the resulting planning model. To solve this problem we present , an algorithm to learn action's costs from unlabeled input plans. We provide theoretical and empirical results showing how can successfully solve this task.
... We add the generated derivation rules to the otherwise unchanged PDDL domains. We used the fast-downward planning system [15] with the heuristic A* for planning. Although not the most advanced heuristic, this is, as far as we know, the best that can handle the structure of the derivation rules as generated by our algorithm. ...
We introduce ontology-mediated planning, in which planning problems are combined with an ontology. Our formalism differs from existing ones in that we focus on a strong separation of the formalisms for describing planning problems and ontologies, which are only losely coupled by an interface. Moreover, we present a black-box algorithm that supports the full expressive power of OWL DL. This goes beyond what existing approaches combining automated planning with ontologies can do, which only support limited description logics such as DL-Lite and description logics that are Horn. Our main algorithm relies on rewritings of the ontology-mediated planning specifications into PDDL, so that existing planning systems can be used to solve them. The algorithm relies on justifications, which allows for a generic approach that is independent of the expressivity of the ontology language. However, dedicated optimizations for computing justifications need to be implemented to enable an efficient rewriting procedure. We evaluated our implementation on benchmark sets from several domains. The evaluation shows that our procedure works in practice and that tailoring the reasoning procedure has significant impact on the performance.
... The gradient is backpropagated for training the model using PyTorch's automatic differentiation. As a planning tool, we use the Fast Downward (FD) planning system Helmert [2006] and run the algorithms described in Section 4.1. For small-size planning problems, we generated 400, 100 and 400 training, validation and test instances. ...
In many automated planning applications, action costs can be hard to specify. An example is the time needed to travel through a certain road segment, which depends on many factors, such as the current weather conditions. A natural way to address this issue is to learn to predict these parameters based on input features (e.g., weather forecasts) and use the predicted action costs in automated planning afterward. Decision-Focused Learning (DFL) has been successful in learning to predict the parameters of combinatorial optimization problems in a way that optimizes solution quality rather than prediction quality. This approach yields better results than treating prediction and optimization as separate tasks. In this paper, we investigate for the first time the challenges of implementing DFL for automated planning in order to learn to predict the action costs. There are two main challenges to overcome: (1) planning systems are called during gradient descent learning, to solve planning problems with negative action costs, which are not supported in planning. We propose novel methods for gradient computation to avoid this issue. (2) DFL requires repeated planner calls during training, which can limit the scalability of the method. We experiment with different methods approximating the optimal plan as well as an easy-to-implement caching mechanism to speed up the learning process. As the first work that addresses DFL for automated planning, we demonstrate that the proposed gradient computation consistently yields significantly better plans than predictions aimed at minimizing prediction error; and that caching can temper the computation requirements.
... For the TAMPSOLVER used in Algorithm 1, the Planning Domain Definition Language (PDDL) [37] is used to define the operators (action schemas) available to the robot. The popular FastDownward solver [38] is used to generate the high-level task skeletons, which are then refined iteratively by a sampler and, when necessary, a motion-level planner. Motion planning-e.g., for the robot's movement between poses-is determined via the RRT-Connect algorithm [39], yielding costs based on Euclidean distances that are then fed back into the planner. ...
We consider a sequential task and motion planning (tamp) setting in which a robot is assigned continuous-space rearrangement-style tasks one-at-a-time in an environment that persists between each. Lacking advance knowledge of future tasks, existing (myopic) planning strategies unwittingly introduce side effects that impede completion of subsequent tasks: e.g., by blocking future access or manipulation. We present anticipatory task and motion planning, in which estimates of expected future cost from a learned model inform selection of plans generated by a model-based tamp planner so as to avoid such side effects, choosing configurations of the environment that both complete the task and minimize overall cost. Simulated multi-task deployments in navigation-among-movable-obstacles and cabinet-loading domains yield improvements of 32.7% and 16.7% average per-task cost respectively. When given time in advance to prepare the environment, our learning-augmented planning approach yields improvements of 83.1% and 22.3%. Both showcase the value of our approach. Finally, we also demonstrate anticipatory tamp on a real-world Fetch mobile manipulator.
Autonomous systems such as space‐ or underwater‐exploration robots or elderly people assistance robots often include an artificial intelligence (AI) planner as a component. Starting from the initial state of a system, an AI planner automatically generates sequential plans to reach final states that satisfy user‐specified goals. Generating plans having a minimum number of intermediate steps or taking the least time to execute is usually strongly desired, as these plans exhibit minimal costs. Unfortunately, testing if an AI planner generates optimal plans is almost impossible because the expected cost of these plans is usually unknown. Based on mutation adequacy test suite selection, this article proposes a novel metamorphic testing framework for detecting the lack of optimality in AI planners. The general idea is to perform a systematic but non‐exhaustive state space exploration from the initial state and to select mutant‐adequate states to instantiate new planning tasks as follow‐up test cases. We then check a metamorphic relation between the automatically generated solutions of the AI planner for these new test cases and the cost of the initial plan. We implemented this metamorphic testing framework in a tool called MorphinPlan . Our experimental evaluation shows that MorphinPlan can detect non‐optimal behaviour in both mutated AI planners and off‐the‐shelf, configurable planners. It also shows that our proposed mutation adequacy test selection strategy outperforms three alternative test generation and selection strategies, including both random state selection and random walks through the state space in terms of mutation scores.
In recent years, the integration of large language models (LLMs) has revolutionized the field of robotics, enabling robots to communicate, understand, and reason with human-like proficiency. This paper explores the multifaceted impact of LLMs on robotics, addressing key challenges and opportunities for leveraging these models across various domains. By categorizing and analyzing LLM applications within core robotics elements—communication, perception, planning, and control—we aim to provide actionable insights for researchers seeking to integrate LLMs into their robotic systems. Our investigation focuses on LLMs developed post-GPT-3.5, primarily in text-based modalities while also considering multimodal approaches for perception and control. We offer comprehensive guidelines and examples for prompt engineering, facilitating beginners’ access to LLM-based robotics solutions. Through tutorial-level examples and structured prompt construction, we illustrate how LLM-guided enhancements can be seamlessly integrated into robotics applications. This survey serves as a roadmap for researchers navigating the evolving landscape of LLM-driven robotics, offering a comprehensive overview and practical guidance for harnessing the power of language models in robotics development.
Coordination between processing entities is one of the most widely studied areas in multi-agent planning research. Recently, efforts have been made to understand the formal computational issues of this important area. In this paper, we make a step toward this direction, and analyze a restricted class of coordina-tion problems for dependent agents with independent goals acting in the same environment. We assume that a state-transition description of each agent is given, and that preconditioning an agent's transitions by the states of other agents is the only considered kind of inter-agent dependence. Off-line coordination between the agents is considered. We analyze some structural properties of these prob-lems, and investigate the relationship between these properties and the complex-ity of coordination in this domain. We show that our general problem is provably intractable, but some significant subclasses are in NP and even polynomial.
We present some techniques for planning in domains specified with the recent
standard language PDDL2.1, supporting 'durative actions' and numerical
quantities. These techniques are implemented in LPG, a domain-independent
planner that took part in the 3rd International Planning Competition (IPC). LPG
is an incremental, any time system producing multi-criteria quality plans. The
core of the system is based on a stochastic local search method and on a
graph-based representation called 'Temporal Action Graphs' (TA-graphs). This
paper focuses on temporal planning, introducing TA-graphs and proposing some
techniques to guide the search in LPG using this representation. The
experimental results of the 3rd IPC, as well as further results presented in
this paper, show that our techniques can be very effective. Often LPG
outperforms all other fully-automated planners of the 3rd IPC in terms of speed
to derive a solution, or quality of the solutions that can be produced.
In recent years research in the planning community has moved increasingly towards application of plan- ners to realistic problems involving both time and many types of resources. For example, interest in planning demonstrated by the space research community has inspired work in observation scheduling, planetary rover exploration and spacecraft control domains. Other temporal and resource-intensive domains including logis- tics planning, plant control and manufacturing have also helped to focus the community on the modelling and reasoning issues that must be confronted to make planning technology meet the challenges of application. The international planning competitions have acted as an important motivating force behind the progress that has been made in planning since 1998. The third competition (held in 2002) set the planning community the challenge of handling time and numeric resources. This necessitated the development of a modelling lan- guage capable of expressing temporal and numeric properties of planning domains. In this paper we describe the language, PDDL2.1, that was used in the competition. We describe the syntax of the language, its formal semantics and the validation of concurrent plans. We observe that PDDL2.1 has considerable modelling power — exceeding the capabilities of current planning technology — and presents a number of important challenges to the research community.
This article complements these results by providing a complete map over the complexity of SAS
We describe and evaluate the algorithmic techniques that are used in the FF
planning system. Like the HSP system, FF relies on forward state space search,
using a heuristic that estimates goal distances by ignoring delete lists.
Unlike HSP's heuristic, our method does not assume facts to be independent. We
introduce a novel search strategy that combines hill-climbing with systematic
search, and we show how other powerful heuristic information can be extracted
and used to prune the search space. FF was the most successful automatic
planner at the recent AIPS-2000 planning competition. We review the results of
the competition, give data for other benchmark domains, and investigate the
reasons for the runtime performance of FF compared to HSP.
Unary operator domains - i.e., domains in which operators have a single effect - arise naturally in many control problems. In its most general form, the problem of STRIPS planning in unary operator domains is known to be as hard as the general STRIPS planning problem - both are P-SPACE complete. However, unary operator domains induce a natural structure, called the domain's causal graph. This graph relates between the preconditions and effect of each domain operator. Causal graphs were introduced by Williams and Nayak in order to analyze plan generation for one of the controllers in NASA's Deep-Space One spacecraft. There, they utilized the fact that when this graph is a tree, a serialization ordering over any subgoal can be obtained quickly. In this paper we conduct a comprehensive study of the relationship between the structure of a domain's causal graph and the complexity of planning in this domain. On the positive side, we show that a non-trivial polynomial time plan generation algorithm exists for domains whose causal graph induces a polytree with a constant bound on its node indegree. On the negative side, we show that even plan existence is hard when the graph is a singly connected DAG - even if its indegree is bounded by a low constant. More generally, we show that the number of paths in the causal graph is closely related to the complexity of planning in the associated domain. Finally we relate our results to the question of complexity of planning with serializable subgoals.
The Harpy connected speech recognition system is the result of an
attempt to understand the relative importance of various design choices
of two earlier speech recognition systems developed at Carnegie-Mellon
University: The Hearsay-1 system and the Dragon system. Knowledge is
represented in the Hearsay-1 system as procedures and in the Dragon
system as a Markov network with a-priori transition probabilities
between states. Systematic performance analysis of various design
choices of these two systems resulted in the HARPY system, in which
knowledge is represented as a finite state transition network but
without the a-priori transition probabilities. Harpy searches only a few
'best' syntactic (and acoustic) paths in parallel to determine the
optimal path, and uses segmentation to effectively reduce the utterance
length, thereby reducing the number of state probability updates that
must be done. Several new heuristics have been added to the HARPY system
to improve its performance and speed: detection of common sub-nets and
collapsing them to reduce overall network size and complexity,
eliminating the need for doing an acoustic match for all phonemic types
at every time sample, and semi-automatic techniques for learning the
lexical representations (that are needed for a steady-state system of
this type) and the phonemic templates from training data, thus
automatically accounting for the commonly occurring intra-word
coarticulation and juncture phenomena. Inter-word phenomena are handled
by the use of juncture rules which are applied at network generation
time, thereby eliminating the need for repetitive and time consuming
application of phonological rules during the recognition phase.
: Effort was directed toward showing that the techniques that have emerged for constructing sophisticated problem-solving programs also provide us with new, strong tools for constructing theories of human thinking. They allow us to merge the rigor and objectivity associated with behaviorism with the wealth of data and complex behavior associated with the gestalt movement. To this end their key feature is not that they provide a general framework for understanding problem-solving behavior (although they do that too), but that they finally reveal with great clarity that the free behavior of a reasonably intelligent human can be understood as the product of a complex but finite and determinate set of laws. Although we know this only for small fragments of behavior, the depth of the explanation is striking. (Author)
This document deenes the language to be used in the classical part of the 4th International Planning Competition, IPC-4. The language comprises all of PDDL2.1 levels 1, 2, and 3, as deened by Maria Fox and Derek Long in 1]] parts of this document h a ve been copied from that source. On top of this language, for IPC-4 derived p r edicates are re-introduced, and timed initial literals are (newly) introduced into the competition language. We give t h e syntax and semantics of these constructs.
Conventional blind search techniques generally assume that the goal nodes for a given problem are distributed randomly along the fringe of the search tree. We argue that this is often invalid in practice and suggest that a more reasonable assumption is that decisions made at each point in the search carry equal weight. We go on to show that a new search technique called iterative broadening leads to orders-of-magnitude savings in the time needed to search a space satisfying this assumption; the basic idea is to search the space using artificial breadth cutoffs that are gradually increased until a goal is found. Both theoretical and experimental results are presented.
Computationally tractable planning problems reported in the literature so far have almost exclusively been defined by syntactical restrictions. To better exploit the inherent structure in problems, it is probably necessary to study also structural restrictions on the underlying state-transition graph. The exponential size of this graph, though, makes such restrictions costly to test. Hence, we propose an intermediate approach, using a state-variable model for planning and defining restrictions on the separate state-transition graphs for each state variable. We identify such restrictions which can tractably be tested and we present a planning algorithm which is correct and runs in polynomial time under these restrictions. The algorithm has been implemented and it outperforms Graphplan on a number of test instances. In addition, we present an exhaustive map of the complexity results for planning under all combinations of four previously studied syntactical restrictions and our five new structural restrictions. This complexity map considers both the optimal and non-optimal plan generation problem.
In the AIPS98 Planning Contest, the hsp planner showed that heuristic search planners can be competitive with state-of-the-art Graphplan and sat planners. Heuristic search planners like hsp transform planning problems into problems of heuristic search by automatically extracting heuristics from Strips encodings. They differ from specialized problem solvers such as those developed for the 24-Puzzle and Rubik's Cube in that they use a general declarative language for stating problems and a general mechanism for extracting heuristics from these representations. In this paper, we study a family of heuristic search planners that are based on a simple and general heuristic that assumes that action preconditions are independent. The heuristic is then used in the context of best-first and hill-climbing search algorithms, and is tested over a large collection of domains. We then consider variations and extensions such as reversing the direction of the search for speeding node evaluation, and extracting information about propositional invariants for avoiding dead-ends. We analyze the resulting planners, evaluate their performance, and explain when they do best. We also compare the performance of these planners with two state-of-the-art planners, and show that the simplest planner based on a pure best-first search yields the most solid performance over a large set of problems. We also discuss the strengths and limitations of this approach, establish a correspondence between heuristic search planning and Graphplan, and briefly survey recent ideas that can reduce the current gap in performance between general heuristic search planners and specialized solvers.
I present several computational complexity results for propositional STRIPS planning, i.e., STRIPS planning restricted to ground formulas. Different planning problems can be defined by restricting the type of formulas, placing limits on the number of pre-and postconditions, by restricting negation in pre- and postconditions, and by requiring optimal plans. For these types of restrictions, I show when planning is tractable (polynomial) and intractable (NP-hard). In general, it is PSPACE-complete to determine if a given planning instance has any solutions. Extremely severe restrictions on both the operators and the formulas are required to guarantee polynomial time or even NP-completeness. For example, when only ground literals are permitted, determining plan existence is PSPACE-complete even if operators are limited to two preconditions and two postconditions. When definite Horn ground formulas are permitted, determining plan existence is PSPACE-complete even if operators are limited to zero preconditions and one postcondition. One of the interesting tractable problems is if each operator is restricted to positive preconditions and one postcondition (only ground literals). The blocks-world problem, slightly modified, is a subproblem of this restricted planning problem. These results in combination with previous analyses are not encouraging for domain-independent planning.
This article presents a completely automated approach to generating abstractions for planning. The abstractions are generated using a tractable, domain-independent algorithm whose only input is the definition of a problem to be solved and whose output is an abstraction hierarchy that is tailored to the particular problem. The algorithm generates abstraction hierarchies by dropping literals from the original problem definition. It forms abstractions that satisfy the ordered monotonicity property, which guarantees that the structure of an abstract solution is not changed in the process of refining it. The algorithm for generating abstractions is implemented in a system called ALPINE, which generates abstractions for a hierarchical version of the PRODIGY problem solver. The abstractions generated by ALPINE are tested in multiple domains on large problem sets and are shown to produce shorter solutions with significantly less search than planning without using abstraction.
Analysis and experiments have shown that hierarchical problem solving is most effective when the hierarchy satisfies the downward refinement property (DRP), whereby every abstract solution can be refined to a concrete-level solution without backtracking across abstraction levels. However, the DRP is a strong requirement that is not often met in practice. In this paper we examine the case when the DRP fails, and provide an analytical model of search complexity parameterized by the probability of an abstract solution being refinable. Our model provides a more accurate picture of the effectiveness of hierarchical problem solving. We then formalize the DRP in Abstrips-style hierarchies, providing a syntactic test that can be applied to determine if a hierarchy satisfies the DRP. Finally, we describe an algorithm called Highpoint that we have developed. This algorithm builds on the Alpine algorithm of Knoblock in that it automatically generates abstraction hierarchies. However, it uses the theoretical tools we have developed to generate hierarchies superior to those generated by Alpine. This superiority is demonstrated empirically.2
A problem domain can be represented as a hierarchy of abstraction spaces in which successively finer levels of detail are introduced. The problem solver ABSTRIPS, a modification of STRIPS, can define an abstraction space hierarchy from the STRIPS representation of a problem domain, and it can utilize the hierarchy in solving problems. Examples of the system's performance are presented that demonstrate the significant increases in problem-solving power that this approach provides. Then some further implications of the hierarchical planning approach are explored.
Unary operator domains - i.e., domains in which operators have a single eect - arise naturally in many control problems. In its most general form, the problem of strips plan- ning in unary operator domains is known to be as hard as the general strips planning problem - both are pspace-complete. However, unary operator domains induce a natural structure, called the domain's causal graph. This graph relates between the preconditions and eect of each domain operator. Causal graphs were exploited by Williams and Nayak in order to analyze plan generation for one of the controllers in NASA's Deep-Space One spacecraft. There, they utilized the fact that when this graph is acyclic, a serialization ordering over any subgoal can be obtained quickly. In this paper we conduct a compre- hensive study of the relationship between the structure of a domain's causal graph and the complexity of planning in this domain. On the positive side, we show that a non-trivial polynomial time plan generation algorithm exists for domains whose causal graph induces a polytree with a constant bound on its node indegree. On the negative side, we show that even plan existence is hard when the graph is a directed-path singly connected DAG. More generally, we show that the number of paths in the causal graph is closely related to the complexity of planning in the associated domain. Finally we relate our results to the question of complexity of planning with serializable subgoals.
In recent years, heuristic search methods for classical plan- ning have achieved remarkable results. Their most successful representative, the FF algorithm, performs well over a wide spectrum of planning domains and still sets the state of the art for STRIPS planning. However, there are some planning do- mains in which algorithms like FF and HSP perform poorly because their relaxation method of ignoring the ìdelete listsî of STRIPS operators loses too much vital information. Planning domains which have many dead ends in the search space are especially problematic in this regard. In some do- mains, dead ends are readily found by the human observer yet remain undetected by all propositional planning systems we are aware of. We believe that this is partly because the STRIPS representation obscures the important causal struc- ture of the domain, which is evident to humans. In this paper, we propose translating STRIPS problems to a planning formalism with multi-valued state variables in or- der to expose this underlying causal structure. Moreover, we show how this structure can be exploited by an algorithm for detecting dead ends in the search space and by a planning heuristic based on hierarchical problem decomposition. Our experiments show excellent overall performance on the benchmarks from the international planning competitions.
The conventional wisdom in the planning community is that planners based on integer programming (IP) techniques cannot compete with satisfiability and con- straint satisfaction based planners. In this paper we challenge this perception of IP techniques by present- ing novel formulations that outperform the most effi- cient SAT-based planner that currently exists. We will present a series of IP formulations that (1) use multi- valued state variables that are represented by networks, and that (2) control the encoding length by progres- sively generalizing the notion of parallelism. The re- sulting IP encodings are solved within a branch-and- cut framework and yield impressive results.
Many state-of-the-art heuristic planners derive their heuristic function by relaxing the planning task at hand, where the relaxation is to assume that all delete lists are empty. The success of such planners on many of the current benchmarks suggests that in those task's state spaces relaxed goal distances yield a heuristic function of high quality. Recent work has revealed empirical evidence confirming this intuition, stating several hypotheses about the local search topology of the current benchmarks, concerning the non-existence of dead ends and of local minima, as well as a limited maximal distance to exits on benches.
We have previously reported a number of tractable planning problems defined in the SAS + formalism. This report complements these results by providing a complete map over the complexity of SAS + planning under all combinations of the previously considered restrictions. We analyze the complexity both of finding a minimal plan and of finding any plan. In contrast to other complexity surveys of planning we study not only the complexity of the decision problems but also of the generation problems. We prove that the SAS + -PUS problem is the maximal tractable problem under the restrictions we have considered if we want to generate minimal plans. If we are satisfied with any plan, then we can generalize further to the SAS + -US problem, which we prove to be the maximal tractable problem in this case. This research was supported by the Swedish National Board for the Engineering Sciences (TFR) under grant Dnr. 92-143, by the German Ministry for Research and Technology (BMFT) under gr...
Many state-of-the-art heuristic planners derive their heuristic function by relaxing the planning task at hand, where the relaxation is to assume that all delete lists are empty. Looking at a collection of planning benchmarks, we measure topological properties of state spaces with respect to that relaxation. The results suggest that, given the heuristic based on the relaxation, many planning benchmarks are simple in structure. This sheds light on the recent success of heuristic planners employing local search.
A new generation of reactive, model-based executives are emerging that make extensive use of componentbased declarative models to analyze anomalous situations and generate novel sequences for the internal control of complex autonomous systems. Burton, a generative, model-based planner offers a core element that bridges the gap between current and target states within the reactive loop. Burton is a sound, complete, reactive planner that generates a single control action of a valid plan in average case constant time, and compensates for anomalies at every step. Burton will not generate irreversible, potentially damaging sequences, except to effect repairs. We present model compilation, causal analysis, and online policy construction methods that are key to Burton's performance.
We present a class of planning instances such that the plan existence problem is tractable while plan generation is provably intractable for instances of this class. The class is defined by simple structural restrictions, all of them testable in polynomial-time. Furthermore, we show that plan generation can be carried out in solution-polynomial time, that is, in time bounded by a polynomial in the size of the input and the size of the generated solution. For this class, we propose a provably sound and complete incremental planner, i.e. a planner that can usually output an executable prefix of the final plan before it has generated the whole plan. This opens up some interesting possibilities for interleaving plan generation with plan execution. Introduction It is well-known that planning is computationally difficult in the general case; plan existence for Strips-style formalisms is undecidable in the first-order case (Chapman 1987) and Pspace-complete for all common p...
Region analysis is a new technique for analyzing search problems by applying graph theory to problem state spaces. The analysis here is of search problems, not search algorithms; analyzing problems and classes of problems lets us understand the underlying structure and inherent complexity of those problems. The analysis technique is demonstrated in the domain of robot planning problems. Region analysis of conjunctive-goal planning problems gives us a characterization of subgoal interactions that is independent of the problem representation. We give a formal characterization of nonlinear planning problems, and show that nonlinearity is a weak characterization of the difficulty in planning problems.
We present the thesis that planning can be viewed as problem-solving search using subgoals, macro-operators, and abstraction as knowledge sources. Our goal is to quantify problem-solving performance using these sources of knowledge. New results include the identification of subgoal distance as a fundamental measure of problem difficulty, a multiplicative time-space tradeoff for macro-operators, and an analysis of abstraction which concludes that abstraction hierarchies can reduce exponential problems to linear complexity.
New algorithms for deciding whether a (propositional) Horn formula is satisfiable are presented. If the Horn formula A contains K distinct propositional letters and if it is assumed that they are exactly P1,…, PK, the two algorithms presented in this paper run in time O(N), where N is the total number of occurrences of literals in A. By representing a Horn proposition as a graph, the satisfiability problem can be formulated as a data flow problem, a certain type of pebbling. The difference between the two algorithms presented here is the strategy used for pebbling the graph. The first algorithm is based on the principle used for finding the set of nonterminals of a context-free grammar from which the empty string can be derived. The second algorithm is a graph traversal and uses a “call-by-need” strategy. This algorithm uses an attribute grammar to translate a propositional Horn formula to its corresponding graph in linear time. Our formulation of the satisfiability problem as a data flow problem appears to be new and suggests the possibility of improving efficiency using parallel processors.
Between 1998 and 2004, the planning community has seen vast progress in terms
of the sizes of benchmark examples that domain-independent planners can tackle
successfully. The key technique behind this progress is the use of heuristic
functions based on relaxing the planning task at hand, where the relaxation is
to assume that all delete lists are empty. The unprecedented success of such
methods, in many commonly used benchmark examples, calls for an understanding
of what classes of domains these methods are well suited for. In the
investigation at hand, we derive a formal background to such an understanding.
We perform a case study covering a range of 30 commonly used STRIPS and ADL
benchmark domains, including all examples used in the first four international
planning competitions. We *prove* connections between domain structure and
local search topology -- heuristic cost surface properties -- under an
idealized version of the heuristic functions used in modern planners. The
idealized heuristic function is called h^+, and differs from the practically
used functions in that it returns the length of an *optimal* relaxed plan,
which is NP-hard to compute. We identify several key characteristics of the
topology under h^+, concerning the existence/non-existence of unrecognized dead
ends, as well as the existence/non-existence of constant upper bounds on the
difficulty of escaping local minima and benches. These distinctions divide the
(set of all) planning domains into a taxonomy of classes of varying h^+
topology. As it turns out, many of the 30 investigated domains lie in classes
with a relatively easy topology. Most particularly, 12 of the domains lie in
classes where FFs search algorithm, provided with h^+, is a polynomial solving
mechanism. We also present results relating h^+ to its approximation as
implemented in FF. The behavior regarding dead ends is provably the same. We
summarize the results of an empirical investigation showing that, in many
domains, the topological qualities of h^+ are largely inherited by the
approximation. The overall investigation gives a rare example of a successful
analysis of the connections between typical-case problem structure, and search
performance. The theoretical investigation also gives hints on how the
topological phenomena might be automatically recognizable by domain analysis
techniques. We outline some preliminary steps we made into that direction.
We provide an overview of the organization and results of the deterministic
part of the 4th International Planning Competition, i.e., of the part concerned
with evaluating systems doing deterministic planning. IPC-4 attracted even more
competing systems than its already large predecessors, and the competition
event was revised in several important respects. After giving an introduction
to the IPC, we briefly explain the main differences between the deterministic
part of IPC-4 and its predecessors. We then introduce formally the language
used, called PDDL2.2 that extends PDDL2.1 by derived predicates and timed
initial literals. We list the competing systems and overview the results of the
competition. The entire set of data is far too large to be presented in full.
We provide a detailed summary; the complete data is available in an online
appendix. We explain how we awarded the competition prizes.
Ph.D. Thesis, Computer Science Dept., U. Rochester; Prof. Dana H. Ballard, thesis advisor; simultaneously published in the Technical Report series. This thesis explores the use of abstraction in planning in order to simplify the task of reasoning about the effects of an agent's actions within a complex world. An abstract representation can be constructed from a concrete one by ignoring details and including only those aspects of primary importance. Two significant issues emerge which form the basis of this thesis. First, the abstract views must sanction plan construction for frequently occurring problems, yet never sanction the deduction of contradictory assertions. Second, a correspondence between the abstract and concrete views must be maintained so that abstract solutions bear a precise relationship to the concrete level solutions derived from them. Abstraction is explored in two settings, both of which guarantee the consistency of the abstract levels. In the first, some of the conditions under which actions can be applied are considered details, and are thus ignored at the abstract level. Systems abstracted in this fashion have the upward-solution property, where the existence of a concrete level solution implies the existence of abstractions to this solution at each higher level. In the second setting, analogy is used as the basis for determining which aspects of a theory are details. Objects belong to object classes arranged in inheritance hierarchies. Each class is characterized by the features common to its members, while details are considered to be those features that distinguish the elements of a class. Object classes are used as the basis for an inheritance structuring on relations between objects, and actions applied to objects. Systems abstracted in this fashion exhibit the downward-solution property, where the existence of an abstract solution implies the existence of specializations of this solution at each lower level.
Many state-of-the-art heuristic planners derive their heuristic function by relaxing the planning task at hand, where the relaxation is to assume that all delete lists are empty. The success of such planners on many of the current benchmarks suggests that in those task's state spaces relaxed goal distances yield a heuristic function of high quality. Recent work has revealed...
In this paper we present a general-purposed algorithm for transforming a planning problem specified in Strips into a concise state description for single state or symbolic exploration.
The process of finding a state description consists of four phases. In the first phase we symbolically analyze the domain specification to determine constant and one-way predicates, i.e. predicates that remain unchanged by all operators or toggle in only one direction, respectively.
In the second phase we symbolically merge predicates invariants which lead to a drastic reduction of state encoding size, while in the third phase we constrain the domains of the predicates to be considered by enumerating the operators of the planning problem. The fourth phase combines the result of the previous phases.
. Ambros-Ingerson and Steel suggested to interleave planning and execution through incremental planning, ie. using a planner that can output valid prefixes of the final plan before it has finished planning. This method could considerably bring down the time lost in planning, especially in dynamic domains, where replanning has to occur frequently. We improve on the basic idea, avoiding certain problems, by presenting an incremental planner with provable properties for a restricted class of planning problems, the 3S class. Finding out whether a 3S instance is solvable or not is computationally tractable, despite the fact that generating a plan is inherently intractable. By first testing whether an instance is solvable or not, we can avoid outputting prefixes of invalid plans in the latter case. Furthermore, making the reasonable assumption that natural problems have non-exponential-size solutions, we can also plan efficiently in practice since we need not waste time on non-...
Abstraction in planning
- J D Tenenberg
- J F Allen
- H A Kautz
- R N Pelavin
- Tenenberg
Tenenberg, J. D. (1991). Abstraction in planning. In Allen, J. F., Kautz, H. A., Pelavin, R. N.,
& Tenenberg, J. D., Reasoning About Plans, chap. 4, pp. 213-283. Morgan Kaufmann, San
Mateo.