A memory-based heuristic is a function, h(s), stored in the form of a lookup table: h(s) is computed by mapping s to an index and then retrieving the corresponding entry in the table. In this paper we present a notation for describing state spaces, PSVN, and a method for automatically creating memory-based heuristics for a state space by abstracting its PSVN description. Two investigations of these automatically generated heuristics are presented. First, thousands of automatically generated heuristics are used to experimentally investigate the conjecture by Korf [4] that m \Delta t is a constant, where m is the size of a heuristic's lookup table and t is the number of nodes expanded when the heuristic is used to guide search. Second, a similar large-scale experiment is used to verify that the Korf and Reid's complexity analysis [5] can be used to rapidly and reliably choose the best among a given set of heuristics.

. Macro search is used to derive solutions quickly for large search spaces at the expense of optimality. We present a novel way of building macro tables. Our contribution is twofold: (1) for the first time, we use automatically generated heuristics to find optimal macros, (2) due to the speed-up achieved by (1), we merge consecutive subgoals to reduce the solution lengths. We use the Rubik's Cube to demonstrate our techniques. For this puzzle, a 44% improvement of the average solution length was achieved over macro tables built with previous techniques. 1

A memory-based heuristic is a function, h(s), stored in the form of a lookup table (pattern database): h(s) is computed by mapping s to an index and then retrieving the appropriate entry in the table. (Korf 1997) conjectures for search using memory-based heuristics that m \Delta t is a constant, where m is the size of the heuristic's lookup table and t is search time. In this paper we present a method for automatically generating memorybased heuristics and use this to test Korf's conjecture in a large-scale experiment. Our results confirm that there is a direct relationship between m and t. Introduction A heuristic is a function, h(s), that computes an estimate of the distance from state s to a goal state. In a memory-based heuristic this computation consists of mapping s to an index which is then used to look up h(s) in a table. Even heuristics that have a normal functional definition are often precomputed and stored in a lookup table in order to speed up search ((Priedi...

There is increasing awareness that planning and model checking are closely related fields. Abstraction means to perform search in an over-approximation of the original problem instance, with a potentially much smaller state space. This is the most essential method in model checking. One would expect that it can also be made successful in planning. We show, however, that this is likely to not be the case. The main reason is that, while in model checking one traditionally uses blind search to exhaust the state space and prove the absence of solutions, in planning informed search is used to find solutions. We give an exhaustive theoretical and practical account of the use of abstraction in planning. For all abstraction (over-approximation) methods known in planning, we prove that they cannot improve the best-case behavior of informed search. While this is easy to see for heuristic search, we were quite surprised to find that it also holds, in most cases, for the resolution-style proofs of unsolvability underlying SATbased optimal planners. This result is potentially relevant also for model checking, where SAT-based techniques have recently been combined with abstraction. Exploring the issue in planning practice, we find that even hand-made abstractions do not tend to improve the performance of planners, unless the attacked task contains huge amounts of irrelevance. We relate these findings to the kinds of application domains that are typically addressed in model checking.

Explicit abstraction heuristics, notably pattern-database and merge-and-shrink heuristics, are employed by some state-ofthe-art optimal heuristic-search planners. The major limitation space has to be bounded by a (large) constant. Targeting this issue, Katz and Domshlak (2008b) introduced structural, and in particular fork-decomposition, abstractions, in which the planning task is abstracted by an instance of a tractable fragment of optimal planning. At first view, however, the lunch was not free. Some of the power of the explicit abstraction heuristics comes from pre-computing the heuristic function offline, and then determine h(s) for each evaluated state s by a very fast lookup in a “database”. In contrast, fork-decomposition offer a poly-time, yet far from being fast, computation. In this contribution, we show that the time-per-node complexity bottleneck of the fork-decomposition heuristics can be successfully overcome. Specifically, we show that an equivalent of the explicit abstractions ’ notion of “database ” exists for the fork-decomposition abstractions as well, and this despite of their exponential-size abstract spaces. Experimentally, we show that heuristic search with such “databased” fork-decomposition heuristics favorably competes with the state-of-the-art of optimal planning.

Planning as satisfiability, as implemented in, for instance, the SATPLAN tool, is a highly competitive method for finding parallel step-optimal plans. A bottleneck in this approach is to prove the absence of plans of a certain length. Specifically, if the optimal plan has n steps, then it is typically very costly to prove that there is no plan of length n−1. We pursue the idea of leading this proof within solution length preserving abstractions (overapproximations) of the original planning task. This is promising because the abstraction may have a much smaller state space; related methods are highly successful in model checking. In particular, we design a novel abstraction technique based on which one can, in several widely used planning benchmarks, construct abstractions that have exponentially smaller state spaces while preserving the length of an optimal plan. Surprisingly, the idea turns out to appear quite hopeless in the context of planning as satisfiability. Evaluating our idea empirically, we run experiments on almost all benchmarks of the international planning competitions up to IPC 2004, and find that even hand-made abstractions do not tend to improve the performance of SATPLAN. Exploring these findings from a theoretical point of view, we identify an interesting phenomenon that may cause this behavior. We compare various planning-graph based CNF encodings φ of the original planning task with the CNF encodings φ σ of the abstracted planning task. We prove that, in many cases, the shortest resolution refutation for φ σ can never be shorter than that for φ. This suggests a fundamental weakness of the approach, and motivates further investigation of the interplay between declarative transition-systems, over-approximating abstractions, and SAT encodings. 1.

Abstraction is a popular technique for speeding up planning and search. A problem that often arises in using abstraction is the generation of abstract states, called spurious states, from which the goal state is reachable in the abstract space but for which there is no corresponding state in the original space from which the goal state can be reached. The experiments in this paper demonstrate that this problem may arise even when standard abstraction methods are applied to benchmark planning problem domains: spurious states cause the pattern databases representing the heuristics to be excessively large and slow down planning and search by reducing the heuristic values. Known automated techniques to get rid of a large portion of spurious states turn out to avoid the memory problem, while at the same time not avoiding the problem of bad heuristic quality. The main contribution of this paper is theoretical. We formally define a characteristic property—the downward path preserving property (DPP)—that guarantees an abstraction will not contain spurious states. How this property can be achieved is studied both for techniques focussing on automated domain-independent abstraction and for techniques focussing on domain-specific abstraction. We analyze the computational complexity of (i) testing the downward path preserving property for a given state space and abstraction and of (ii) determining whether this property is achievable at all for a given state space. Strong hardness results show a close connection between these decision problems and the plan existence problem in typical planning settings including sas + and propositional strips. On the positive side, we identify formal conditions under which finding downward path preserving abstractions is provably tractable and show that some popular heuristic search and planning domains have an encoding that matches these conditions. This includes a new encoding of the Blocks World domain, for which DPP abstractions can be easily defined. 1.

Move pruning is a low-overhead technique for reducing the size of a depth first search tree. The existing algorithm for automatically discovering move pruning information is restricted to games where all moves can be applied to every state. This paper demonstrates an algorithm which handles a general class of single player games. It gives experimental results for our technique, demonstrating both the applicability to a range of games, and the reduction in search tree size. We also provide some conditions under which move pruning is safe, and when it may interfere with other search reduction techniques.