Pattern Selection for Optimal Classical Planning with Saturated Cost Partitioning
Abstract
Pattern databases are the foundation of some of the strongest admissible heuristics for optimal classical planning.
Experiments showed that the most informative way of combining information from multiple pattern databases is to use saturated cost partitioning.
Previous work selected patterns and computed saturated cost partitionings over the resulting pattern database heuristics in two separate steps.
We introduce a new method that uses saturated cost partitioning to select patterns and show that it outperforms all existing pattern se- lection algorithms.
Introduction
A ∗ search (Hart, Nilsson, and Raphael 1968) with an admissible heuristic (Pearl 1984) is one of the most successful methods for solving classical planning tasks optimally.
An important building block of some of the strongest admissible heuristics are pattern database (PDB) heuristics.
A
PDB heuristic precomputes all goal distances in a simpliﬁed state space obtained by projecting the task to a subset of state variables, the pattern , and uses these distances as lower bounds on the true goal distances.
PDB heuristics were originally introduced for solving the 15-puzzle (Culberson and Schaeffer 1996) and have later been generalized to many other combinatorial search tasks (e.g., Korf 1997;
Felner, Korf, and Hanan 2004) and to the setting of domainindependent planning (Edelkamp 2001).
Using a single PDB heuristic of reasonable size is usually not enough to cover sufﬁciently many aspects of challenging planning tasks.
It is therefore often beneﬁcial to compute multiple PDB heuristics and to combine their estimates admissibly (Holte et al. 2006).
The simplest approach for this is to choose the PDB with the highest estimate in each state.
Instead of this maximization scheme, we would like to sum estimates, but this renders the resulting heuristic inadmissible in general.
However, if two PDBs are affected by disjoint sets of operators, they are independent and we can admissibly add their estimates (Korf and Felner 2002;
Felner, Korf, and Hanan 2004).
Haslum et al.
(2007) later generalized this idea by introducing the canonical heuristic for PDBs, which computes all maximal subsets of pairwise independent PDBs and then uses the maximum over the sums of independent PDBs as the heuristic value.
Cost partitioning (Katz and Domshlak 2008; Yang et al.
2008) is a generalization of the independence-based methods above.
It makes the sum of heuristic estimates admissible by distributing the costs of each operator among the heuristics.
The literature contains many different cost partitioning algorithms such as zero-one cost partitioning (Edelkamp 2002;
Haslum et al.
2007), uniform cost partitioning (Katz and Domshlak 2008), optimal cost partitioning (Katz and Domshlak 2008; Karpas and Domshlak 2009;
Katz and Domshlak 2010; Pommerening et al. 2015), posthoc optimization (Pommerening, R ¨ oger, and Helmert 2013) and delta cost partitioning (Fan, M¨uller, and Holte 2017).
In previous work (Seipp, Keller, and Helmert 2017a), we showed experimentally for the benchmark tasks from previous International Planning Competitions (IPC) that saturated cost partitioning (SCP) (Seipp and Helmert 2014; 2018) is the cost partitioning algorithm of choice for PDB heuristics.
Saturated cost partitioning considers an ordered sequence of heuristics.
Iteratively, it gives each heuristic the minimum amount of costs that the heuristic needs to justify all its estimates and then uses the remaining costs for subsequent heuristics until all heuristics have been served this way.
Before we can compute a saturated cost partitioning over pattern database heuristics, we need to select a collection of patterns.
The ﬁrst domain-independent automated pattern selection algorithm is due to Edelkamp (2001).
It partitions the state variables into patterns via best-ﬁt bin packing.
Edelkamp (2006) later used a genetic algorithm to search for a pattern collection that maximizes the average heuristic value of a zero-one cost partitioning over the PDB heuristics.
Haslum et al.
(2007) proposed an algorithm that performs a hill-climbing search in the space of pattern collections (HC).
HC evaluates a collection C by estimating the search effort of the canonical heuristic over C based on a model of
IDA ∗ runtime (Korf, Reid, and Edelkamp 2001).
Franco et al.
(2017) presented the Complementary PDBs
Creation (CPC) method, that combines bin packing and genetic algorithms to create a pattern collection minimizing the estimated search effort of an A ∗ search (Lelis, Stern, and
Sturtevant 2014).
Rovner, Sievers, and Helmert (2019) repeatedly compute patterns using counterexample-guided abstraction reﬁnement (CEGAR): starting from a random goal variable, their CEGAR algorithm iteratively ﬁnds solutions in the corresponding projection and executes them in the original state space.
Whenever a solution cannot be executed due to a violated precondition, it adds the missing precondition variable to the pattern.
Finally, Pommerening, R¨oger, and Helmert (2013) systematically generate all interesting patterns up to a given size X (S YS -X).
Experiments showed that cost-partitioned heuristics over S YS -2 and S YS -3 yield accurate estimates (Pommerening, R¨oger, and Helmert 2013; Seipp, Keller, and
Helmert 2017a), but using all interesting patterns of larger sizes is usually infeasible.
We introduce S YS -SCP, a new pattern selection algorithm based on saturated cost partitioning that potentially considers all interesting patterns, but only selects useful ones.
S YS -SCP builds multiple pattern sequences that together form the resulting pattern collection.
For each sequence σ , it considers the interesting patterns in increasing order by size and adds a pattern P to σ if P is not part of an earlier sequence and the saturated cost partitioning heuristic over σ plus P is more informative than the one over σ alone.
Background
We consider optimal classical planning tasks in a SAS + -like notation (B ¨ ackstr ¨ om and Nebel 1995) and represent a planning task Π as a tuple (cid:104)V , O , s 0 , s (cid:63) (cid:105) .
Each variable v in the ﬁnite set of variables V has a ﬁnite domain dom ( v ) .
A partial state s is deﬁned over a subset of variables
vars ( s ) ⊆ V and maps each v ∈ vars ( s ) to a value in dom ( v ) , written as s [ v ] .
We call the pair (cid:104) v, s [ v ] (cid:105) an atom and interchangeably treat partial states as mappings from variables to values or as sets of atoms.
If vars ( s ) =
V , we call s a state .
We write
S (Π) for the set of all states in Π .
Each operator o in the ﬁnite set of operators O has a precondition pre ( o ) and an effect eff ( o ) , both of which are partial states, and a cost cost ( o ) ∈ R +0 .
An operator o is applicable in a state s if pre ( o ) ⊆
s .
Applying o in s leads into state s (cid:48)
=
s (cid:74) o
(cid:75) with s (cid:48)
[ v ] = eff
( o )[ v ] for all v ∈ vars ( eff ( o )) and s (cid:48)
[ v ] =
s [ v ] for all variables v ∈ V \ vars ( eff ( o )) .
The state s 0 is called the initial state and s (cid:63) is a partial state, the goal .
Transition systems assign semantics to planning tasks.
Deﬁnition 1.
Transition Systems.
A transition system T is a labeled digraph deﬁned by a ﬁnite set of states S ( T ) , a ﬁnite set of labels L ( T ) , a set T ( T ) of labeled transitions s (cid:96) −→ s (cid:48) with s, s {+(cid:
 )+} ∈ S ( T ) and (cid:96) ∈
L ( T ) , an initial state s 0 ( T ) , and a set S (cid:63) ( T ) of goal states .
A planning task Π
= (cid:104)V , O , s 0 , s (cid:63) (cid:105) induces a transition system T with states S (Π) , labels O , transitions { s o −→ s (cid:74) o
(cid:75) | s ∈ S (Π) , o ∈ O , pre ( o ) ⊆
s } ,
initial state s 0 and goal states { s ∈ S (Π) | s (cid:63) ⊆
s } .
Separating transition systems from cost functions allows us to evaluate the same transition system under different cost functions, which is important for cost partitioning.
Deﬁnition 2.
Cost Functions.
A cost function for transition system T is a function cost :
L ( T ) → R ∪ {−∞ , ∞} .
It is ﬁnite if −∞ < cost ( (cid:96) ) <
∞ for all labels (cid:96) .
It is non-negative if cost ( (cid:96) ) ≥ 0 for all labels (cid:96) .
We write C ( T ) for the set of all cost functions for T .
Note that we assume that the cost function of the planning task is non-negative and ﬁnite, but we allow negative (Pommerening et al. and inﬁnite costs (Seipp and Helmert 2019) in cost partitionings. The latter generalization is necessary to cleanly state some of our deﬁnitions.
Deﬁnition 3.
Weighted Transition Systems.
A weighted transition system is a pair (cid:104)T , cost (cid:105) where T is a transition system and cost ∈ C ( T ) is a cost function for
T .
The cost of a path π = (cid:104) s 0 (cid:96) 1 −→ s 1 , . .
, s n − 1 (cid:96) n −→ s n (cid:105) in a weighted transition system (cid:104)T , cost (cid:105) is deﬁned as cost ( π ) =
(cid:80) ni
=1 cost ( (cid:96) i ) .
It is ∞ if the sum contains both + ∞ and −∞ .
If s n is a goal state, π is called a goal path for s 0 .
Deﬁnition 4.
Goal Distances and Optimal Paths.
The goal distance of a state s ∈ S ( T ) in a weighted transition system (cid:104)T , cost (cid:105) is deﬁned as inf π ∈ Π (cid:63) ( T ,s ) cost ( π ) , where Π (cid:63) ( T , s ) is the set of goal paths from s in T .
(The inﬁmum of the empty set is ∞ .)
We write h ∗T ( cost , s ) for the goal distance of s .
If h ∗T ( cost , s ) = ∞ , we call s unsolvable .
A goal path π from s is optimal if cost ( π ) =
h ∗T ( cost , s ) .
Optimal classical planning is the problem of ﬁnding an optimal goal path from s 0 or showing that s 0 is unsolvable.
We use heuristics to estimate goal distances (Pearl 1984).
Deﬁnition 5.
Heuristics.
A heuristic for a transition system T is a function h : C ( T ) ×
S ( T ) → R ∪ {−∞ , ∞} .
Heuristic h is admissible if h ( cost , s ) ≤ h ∗T ( cost , s ) for all cost ∈ C ( T ) and all s ∈ S ( T ) .
Cost partitioning makes adding heuristics admissible by distributing the costs of each operator among the heuristics.
Deﬁnition 6.
Cost Partitioning.
Let T be a transition system.
A cost partitioning for a cost function cost ∈ C ( T ) is a tuple (cid:104) cost 1 , . .
, cost n (cid:105) ∈ C ( T ) n whose sum is bounded by cost: (cid:80) ni
=1 cost i ( (cid:96) )
≤ cost ( (cid:96) ) for all (cid:96) ∈
L ( T ) .
A cost partitioning (cid:104) cost 1 , . .
, cost n (cid:105) ∈
C ( T ) n over the heuristics (cid:104) h 1 , . . , h n (cid:105) for T induces the cost-partitioned heuristic h ( cost , s )
= (cid:80) ni
=1 h i ( cost i , s ) .
If the sum contains + ∞ and −∞ , it evaluates to the leftmost inﬁnite value.
One of the cost partitioning algorithms from the literature is saturated cost partitioning (Seipp and Helmert 2018).
It is based on the insight that we can often reduce the amount of costs given to a heuristic without changing any heuristic estimates.
Saturated cost functions formalize this idea.
Deﬁnition 7.
Saturated Cost Function.
Consider a transition system T , a heuristic h for T and a cost function cost ∈ C ( T ) .
A cost function scf ∈ C ( T ) is saturated for h and cost if
1. scf ( (cid:96) ) ≤ cost ( (cid:96) ) for all labels (cid:96)
∈ L ( T ) and 2.
h ( scf , s ) =
h ( cost , s ) for all states s ∈ S ( T ) .
A saturated cost function scf is minimal if there is no other saturated cost function scf (cid:48) for h and cost with scf ( (cid:96) )
≤ scf (cid:48)
( (cid:96) ) for all labels (cid:96)
∈ L ( T ) .
Whether we can efﬁciently compute a minimal saturated cost function depends on the type of heuristic.
In earlier work (Seipp and Helmert 2018), we showed that this is possible for explicitly-represented abstraction heuristics (Helmert, Haslum, and Hoffmann 2007), which include PDB heuristics.
Deﬁnition 8.
Minimum Saturated Cost Function for Abstraction Heuristics.
Let (cid:104)T , cost (cid:105) be a weighted transition [-system, cost ∈ C ≥ 
 ( T ) a non-negative cost function for T-]system and h an abstraction heuristic for T with abstract transition system T (cid:48) .
The minimum saturated cost function mscf for h and cost is mscf
[Equation]
for all (cid:96) ∈ L ( T ) , where x − y =
−∞ iff x = −∞ or y = ∞ .
Given a sequence of abstraction heuristics, the saturated cost partitioning algorithm iteratively assigns to each heuristic only the costs that the heuristic needs to preserve its estimates and uses the remaining costs for subsequent heuristics.
Deﬁnition 9.
Saturated Cost Partitioning.
Consider a transition system T and a sequence of abstraction heuristics H = (cid:104) h 1 , . .
, h n (cid:105) for T .
For all 1 ≤ i ≤ n , saturate i : C ( T ) → C ( T ) receives a cost function rem and returns the minimum saturated cost function for h i and rem.
The saturated cost partitioning (cid:104) cost 1 , . .
, cost n (cid:105) of a function cost ∈ C ( T ) over H is deﬁned as:
[Equation]
cost i = saturate i ( rem i − 1 ) for all 1 ≤ i ≤ n rem i = rem i − 1 − cost i for all 1 ≤ i ≤ n, where the auxiliary cost functions rem i represent the remaining costs after processing the ﬁrst i heuristics in H .
We write h SCP H for the saturated cost partitioning heuristic over the sequence of heuristics H .
In this work, we compute saturated cost partitionings over pattern database heuristics.
A pattern for task Π with variables V is a subset P ⊆ V .
By syntactically removing all variables from Π that are not in P , we obtain the projected task Π
| P inducing the abstract transition system T P .
The PDB heuristic h P for a pattern P is deﬁned as h P ( cost , s ) =
h ∗T P ( cost , s | P ) , where s | P is the abstract state that s is projected to in Π | P .
For the pattern sequence (cid:104) P 1 , . . .
, P n (cid:105) we deﬁne h SCP (cid:104) P 1 ,...,P n (cid:105)
=
h SCP (cid:104) h P 1 ,...,h Pn (cid:105) .
One of the simplest pattern selection algorithms is to generate all patterns up to a given size X (Felner, Korf, and
Hanan 2004)
and we call this approach S YS -N
AIVE -X.
It is easy to see that for tasks with n variables, S YS -N AIVE -X generates (cid:80) Xi
=1 (cid:0) ni (cid:1) patterns.
Usually, many of these patterns do not add much information to a cost-partitioned heuristic over the patterns.
Unfortunately, there is no efﬁciently computable test that allows us to discard such uninformative patterns.
Even patterns without any goal variables can increase heuristic estimates in a cost partitioning (Pommerening 2017).
However, in the setting where only non-negative cost functions are allowed in cost partitionings, there are efﬁciently computable criteria for deciding whether a pattern
Algorithm
S ( T ) , cost function cost and interesting patterns S YS , select a subset C ⊆ S YS .
1: function S YS -SCP( Π ) 2:
C ← ∅ 3: repeat for at most T x seconds 4: σ ← (cid:104)(cid:105) 5: for P ∈ O RDER (S YS ) and at most T y seconds do 6: if P / ∈ C and P ATTERN U SEFUL ( σ , P ) then 7: σ ← σ ⊕ P 8:
C ← C ∪ { P } 9: until σ = (cid:104)(cid:105) 10: return C 11: function P ATTERN U SEFUL ( σ , P ) 12: return ∃ s ∈ S ( T ) : h SCP σ ( cost , s ) <
h SCP σ ⊕ P ( cost , s ) < ∞ is interesting , i.e., whether it cannot be replaced by a set of smaller patterns that together yield the same heuristic estimates (Pommerening, R ¨ oger, and Helmert 2013).
The criteria are based on the causal graph CG (Π) of a task Π (Helmert 2004).
CG (Π) is a directed graph with a node for each variable in Π .
If there is an operator with a precondition on u and an effect on v (cid:54) =
u , CG (Π) contains a precondition arc from u to v .
If an operator affects both u and v , CG (Π) contains co-effect arcs from u to v and from v to u .
Deﬁnition 10.
Interesting Patterns.
A pattern P is interesting if
CG (Π | P ) is weakly connected, and 2.
CG (Π | P ) contains a directed path via precondition arcs from each node to some goal variable node.
The systematic pattern generation method S YS -X generates all interesting patterns up to size X .
We let S YS denote the set of all interesting patterns for a given task.
On IPC benchmark tasks, S YS -X often generates much fewer patterns than S YS -N AIVE -X
for the same size limit X .
Still, it is usually infeasible to compute all S YS -X patterns and the corresponding projections for X > 3 within reasonable amounts of time and memory.
Also, we hypothesize that even when considering only interesting patterns, usually only a small percentage of the systematic patterns up to size 3 contribute much information to the resulting heuristic.
For these two reasons we propose a new pattern selection algorithm that potentially considers all interesting patterns, but only selects the ones that it deems useful.
Sys-SCP Pattern Selection Algorithm
Our new pattern selection algorithm repeatedly creates a new empty pattern sequence σ and only appends those interesting patterns to σ that increase any ﬁnite heuristic values of a saturated cost partitioning heuristic computed over σ .
Algorithm 1 shows pseudo-code for the procedure, which we call S YS -SCP.
It starts with an empty pattern collection
C .
In each iteration of the outer loop, S YS -SCP creates a new empty pattern sequence σ and then loops over the interesting patterns P ∈ S YS in the order chosen by O RDER (see Section 3.2) for at most T y seconds.
S YS -SCP appends a pattern P to σ and includes it in C if there is a state s for which the saturated cost partitioning over σ extended by P has a higher ﬁnite heuristic value than the one over σ alone.
Once an iteration selects no new patterns or S YS -SCP hits the time limit T x , the algorithm stops and returns C .
We impose a time limit T x on the outer loop of the algorithm since the number of interesting patterns is exponential in the number of variables and therefore S YS -SCP usually cannot evaluate them all in a reasonable amount of time. By imposing a time limit T y on the inner loop, we allow S YS -SCP to periodically start over with a new empty pattern sequence.
The most important component of the S YS -SCP algorithm is the P ATTERN U SEFUL function that decides whether to select a pattern P .
The function enumerates all states s ∈ S (Π) , which is obviously infeasible for all but the smallest tasks Π .
Fortunately, we can efﬁciently compute an equivalent test in the projection to P .
Lemma 1.
Consider a planning task Π with non-negative cost function cost and induced transition system T .
Let s ∈ S ( T ) be a state, P be a pattern for Π and σ be a (possibly empty) sequence of patterns (cid:104) P 1 , . .
, P n (cid:105) for Π .
Finally, let rem be the remaining cost function after computing h SCP σ for cost.
[Equation]
Proof.
h
[Equation]
σ ( cost ,
[Equation]
<
[Equation]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
[Table]
[Equation]
Step 1 substitutes (cid:104) P 1 , . .
P n (cid:105) for σ and Step 2 uses the deﬁnition of saturated cost partitioning heuristics.
For Stepwe need to show that x = (cid:80) ni
=1 h P
i ( cost i , s ) is ﬁnite.
The inequality states x < ∞ .
We now show x ≥ 0 , which implies x > −∞ .
Using requirement 1 for saturated cost functions from Deﬁnition 7 and the fact that rem 0 = cost is non-negative, it is easy to see that all remaining cost functions are non-negative.
Consequently, h P i ( cost i , s )
=
h P i ( rem i − 1 , s ) ≥ 0 for all s ∈ S ( T ) , which uses requirement 2 from Deﬁnition 7 and the fact that goal distances are non-negative in transition systems with non-negative weights.
Step4 uses the deﬁnition of PDB heuristics.
Theorem 1.
Computing P ATTERN U SEFUL efﬁciently.
Consider a planning task Π with non-negative cost function cost and induced transition system T .
Let P be a single pattern and σ be a (possibly empty) sequence of patterns.
Finally, let rem be the remaining cost function after computing [Table] for cost.
[Table]
s (cid:48) )
< ∞
Proof.
Follows directly from Lemma 1 and the fact that projections are induced abstractions: for each abstract state s (cid:48) in an induced abstraction there is at least one concrete state s which is projected to s (cid:48) .
We use Theorem 1 in our S YS -SCP implementation by keeping track of the cost function rem , i.e., the costs that remain after computing h SCP σ .
We select a pattern P if there are any goal distances d with 0 < d < ∞ in T P under rem .
Theorem 1 also removes the need to compute h SCP σ ⊕ P from scratch for every pattern P .
This is important since we want to decide whether or not to add P quickly and this operation should not become slower when σ contains more patterns.
3. Dead Ends
To obtain high ﬁnite heuristic values for solvable states it is important to choose good cost partitionings. In contrast, cost functions are irrelevant for detecting unsolvable states. This is the underlying reason why Lemma 1 only holds for ﬁnite values and therefore why S YS -SCP ignores unsolvable states.
However, we can still use the information about unsolvable states contained in projections. It is easy to see that each abstract state in a projection corresponds to a partial state in the original task. If an abstract state is unsolvable in a projection, we call the corresponding partial state a dead end . Since projections preserve all paths, any state in the original task subsuming a dead end is unsolvable.
We can extract all dead ends from the projections that S YS -SCP evaluates and use this information to prune unsolvable states during the A ∗ search (Pommerening and Seipp 2016).
3. Ordering Patterns
We showed in earlier work that the order in which saturated cost partitioning considers the component heuristics has a strong inﬂuence on the quality of the resulting heuristic (Seipp, Keller, and Helmert 2017b).
Choosing a good order is even more important for S YS -SCP, since it usually only sees a subset of interesting patterns within the allotted time.
To ensure that this subset of interesting patterns covers different aspects of the planning task, we let the O RDER function generate the interesting patterns in increasing order by size.
Thisleaves the question how to sort patterns of the same size.
We propose four methods for making this decision.
The ﬁrst one ( random ) simply orders patterns of the same size randomly.
The remaining three assign a key to each pattern, allowing us to sort by key in increasing or decreasing order.
Causal Graph The ﬁrst ordering method is based on the insight that it is often more important to have accurate heuristic estimates near the goal states rather than elsewhere in the state space (e.g., Holte et al. 2006;
Torralba,
Linares L´opez, and Borrajo 2018).
We therefore want to focus on patterns containing goal variables or variables that are closely connected to goal variables.
To quantify “goalconnectedness” we use an approximate topological ordering ≺ of the causal graph CG (Π) .
We let the function cg :
V → N +0 assign each variable v ∈ V to its index in ≺ .
For a given pattern P , the cg ordering method returns the key (cid:104) cg ( v 1 ) , . . .
, cg ( v n ) (cid:105) , where v i ∈ P and cg ( v i ) <
cg ( v j ) for all 1 ≤ i < j ≤ n .
Since the keys are unique, they deﬁne a total order.
Sorting the patterns by cg in decreasing order ( cg-down ), yields the desired order which starts with “goal-connected” patterns.
States in Projection Given a pattern P the ordering method states returns the key | S (Π | P ) | , i.e., the number of states in the projection to P .
We use cg-down to break ties.
Active Operators Given a pattern P , the ops ordering method returns the number of operators that affect a variable in P .
We break ties with cg-down .
Experiments
We implemented the S YS -SCP pattern selection algorithm in the Fast Downward planning system (Helmert 2006) and conducted experiments with the Downward Lab toolkit (Seipp et al. 2017) on Intel Xeon Silver 4114 processors.
Our benchmark set consists of all 1827 tasks without conditional effects from the optimization tracks of the 1998–2018 IPCs.
The tasks belong to 48 different domains.
We limit time by 30 minutes and memory by 3.5 GiB. All benchmarks 1 , codeand experimental data 3 have been published online.
To fairly compare the quality of different pattern collections, we use the same cost partitioning algorithm for all collections.
Saturated cost partitioning is the obvious choice for the evaluation since experiments showed that it is preferable to all other cost partitioning algorithms for HC, S YSand CPC patterns in almost all evaluated benchmark domains (Seipp, Keller, and Helmert 2017a; Rovner, Sievers, and Helmert 2019).
Diverse Saturated Cost Partitioning Heuristics For a given pattern collection C , we compute diverse saturated cost partitioning heuristics using the diversiﬁcation procedure by Seipp, Keller, and Helmert (2017b): we start with an empty family of saturated cost partitioning heuristics F and a set ˆ S of 1000 sample states obtained with random walks (Haslum et al. 2007).
Then we iteratively sample a new state s and compute a greedy order ω of C that works well for s (Seipp 2017).
If h SCP ω has a higher heuristic estimate for any state s (cid:48) ∈ ˆ S than all heuristics in F , we add h SCP ω to
F .
We stop this diversiﬁcation procedure after 200 seconds and then perform an A ∗ search using the maximum over the heuristics in F . [Table] Benchmarks: https://doi.org/10.5281/zenodo. [Table]
Code: https://doi.org/10.5281/zenodo.
[Table]
[Table] : https://doi.org/ [Table] [Table]
Coverage 10s 100s 1000s ∞ 1s    10s    100s    ∞    c gup s t a t e s - up r a ndo m op sdo w n s t a t
e s - do w n op sup c gdo w n
Coverage cg-up –
[Table]
[Table]
Before we compare S YS -SCP to other pattern selection algorithms, we evaluate the effects of changing its parameters in four ablation studies.
We use at most 2M states per
PDB and 20M states in the PDB collection for all S YS -SCP runs.
4. Time Limits
Table 1 shows that a time limit for the outer loop is more important than one for the inner loop, but for maximum coverage we need both limits.
The combination that solves the highest number of tasks is 10s for the inner and 100s for the outer loop.
We use these values in all other experiments.
4. Dead Ends
All conﬁgurations from Table 1 store the dead ends from all projections evaluated by S YS -SCP and use them to prune unsolvable states during the A ∗ search.
For the best conﬁguration from Table 1, coverage decreases from 1168 totasks if we ignore the dead ends.
Therefore, we use dead ends for pruning unsolvable states in all other experiments.
4. Pattern Orders
Table 2 compares the different methods for ordering patterns of the same size.
For all of states , ops and cg , at least one or-
[Table] dering direction ( up or down ) is preferable to using random orders.
The ops-up method is preferable to ops-down fordomains, but there are also 7 domains where the opposite is the case. The relation between states-down and states-up is similar.
The only ordering method where one direction is clearly preferable to the other is cg : cg-down solves more tasks than cg-up in 12 domains, while the opposite is the case in only 3 domains.
Since cg-down also has the highest overall coverage, we use it in all other experiments.
4. Using Pattern Sequences for Diversiﬁcation
Instead of discarding the computed pattern sequences when
S YS -SCP ﬁnishes, we can turn each pattern sequence σ into a full pattern order by randomly appending all S YS -SCP patterns missing from σ to σ and pass the resulting order to the diversiﬁcation procedure.
Feeding the diversiﬁcation exclusively with such orders leads to solving 1130 tasks, while using only greedy orders for sample states (Seipp 2017) solves 1156 tasks.
We obtain the best results by diversifying both types of orders, solving 1168 tasks, and we use this variant in all other experiments.
4. Systematic Patterns With Limits
In the next experiment, we evaluate the obvious baseline for
S YS -SCP: selecting all (interesting) patterns up to a ﬁxed size.
Table 3 holds coverage results of S YS -N AIVE -X and
S YS -X for 1 ≤ X ≤ 5 .
We also include variants (*-L IM ) that use at most 100 seconds, no more than 2M states in each projection and at most 20M states per collection.
For the *-
L IM variants, we sort the patterns in the cg-down order.
The results show that interesting patterns are always preferable to naive patterns, both with and without limits, which is why we only consider interesting patterns in
S YS -SCP.
Imposing limits is not important for S YS -1 and
S YS -2, but leads to solving many more tasks for X ≥ 3 .
Overall, S YS -3-L IM has the highest total coverage ( tasks).
4. Comparison of Pattern Selection Algorithms
In Table 4 we compare S YS -SCP to the strongest pattern selection algorithms from the literature: HC, S YS -3-L IM ,
CPC and CEGAR.
(See Table 6 for per-domain coverage results.)
We run each algorithm with its preferred parameter values, which implies using at most 900s for HC and CPC and 100s for the other algorithms. HC is outperformed by all other algorithms.
Interestingly, already the simple S YS -3-L IM approach is competitive with
[Table]
CPC and CEGAR.
However, we obtain the best results with
S YS -SCP. It is preferable to all other pattern selection algorithms in per-domain comparisons: no algorithm has higher coverage than S YS -SCP in more than three domains, while
S YS -SCP solves more tasks than each of the other algorithms in at least 21 domains. S YS -SCP also has the highest total coverage of 1168 tasks, solving 70 more tasks than the strongest contender.
This is a considerable improvement in the setting of optimal classical planning, where task difﬁculty tends to scale exponentially.
4. Comparison to IPC Planners
In our ﬁnal experiment, we evaluate whether Scorpion (Seipp 2018), one of the strongest optimal planners in IPC 2018, beneﬁts from using S YS -SCP patterns.
Scorpion computes diverse saturated cost partitioning heuristics over
HC and S YS {+-
+} PDB heuristics and Cartesian abstraction heuristics (C ART )
(Seipp and Helmert 2018).
We abbreviate this combination with C OMB =HC+S
YS -2+C ART .
In Table 5 we compare the original Scorpion planner, three Scorpion variants that use different sets of heuristics and the top three optimal planners from IPC 2018, Delﬁ 1 (Sievers et al. 2019), Complementary 1 (Franco et al. 2018) and Complementary 2 (Franco et al. 2017).
(Table 6 holds perdomain coverage results.)
In contrast to the conﬁgurations we evaluated above, all planners in Table 5 prune irrelevant operators in a preprocessing step (Alc ´ azar and Torralba 2015).
The results show that all Scorpion variants outperform the top three IPC 2018 planners in per-domain comparisons.
We also see that Scorpion beneﬁts from using S YS -SCP PDBs instead of the C OMB heuristics in many domains.
Using the union of both sets is clearly preferable to using either
C OMB or S YS -SCP alone, since it raises the total coverage to 1261 by 56 and 44 tasks, respectively.
For maximum coverage (1265 tasks), Scorpion only needs S YS -SCP PDBs and Cartesian abstraction heuristics.
Conclusion
We introduced a new pattern selection algorithm based on saturated cost partitioning and showed that it outperforms
C o m p l e m e n t a r y C o m p l e m e n t a r y
D e l ﬁ
C O
M B
S Y SS C P
S Y SS C P + C A
R T
S Y SS C P + C O
M B
C ov
e r a g e
[Table]
S c
o r p i on
C OMB
[Table]
all other pattern selection algorithms from the literature.
The algorithm selects a pattern if it is useful for any state in the state space.
In future work, we would like to evaluate whether it is beneﬁcial to restrict this criterion to a subset of states, such as all reachable states or a set of sample states. Acknowledgments
We thank the anonymous reviewers for their helpful comments.
We have received funding for this work from the
European Research Council (ERC) under the European
Union’s Horizon 2020 research and innovation programme (grant agreement no. 817639).