Revisiting Dominance Pruning in Decoupled Search
Abstract
In classical planning as heuristic search, duplicate state prun-
ing is a standard method to avoid unnecessarily handling the same state multiple times.
In decoupled search, similar to symbolic search approaches, search nodes, called decoupled states , do not correspond to individual states, but to entire sets of states.
As a result, duplicate state pruning cannot be ap- plied in a straightforward manner.
Instead, dominance pruning is employed, taking into account the state sets.
We observe that the time required for dominance checking dom- inates the overall runtime, and propose two ways of tackling this issue.
Our main contribution (1) is a stronger vari- ant of dominance checking for optimal planning, where efﬁciency and pruning power are most crucial.
The new vari- ant greatly improves the latter, without incurring a computational overhead.
Furthermore, (2) we develop and implement three methods that make the dominance check more efﬁcient: exact duplicate checking, which, albeit resulting in weaker pruning, can pay off due to the use of hashing; avoiding the dominance check when leaf state spaces are invertible; and exploiting the transitivity of the dominance relation to only check against the relevant subset of visited decoupled states.
We show empirically that all our improvements are indeed beneﬁcial across many standard benchmark domains.
Introduction
In classical planning, the most popular approach to solve planning tasks is heuristic search in the explicit state space (Bonet and Geffner 1999).
Heuristic search, however, suffers from the state explosion problem that arises from the fact that the size of the state space of a task is exponential in the size of its description.
Many methods have been introduced to tackle this explosion, such as partialorder reduction (Valmari 1989; Godefroid and Wolper 1991;
Edelkamp, Leue and Lluch-Lafuente 2004; Alkhazraji et al.
Wehrle et al. 2013;
Wehrle and Helmert 2014), symmetry breaking (Starke 1991; Pochter, Zohar, and Rosenschein 2011; Domshlak, Katz, and Shleyfman 2012), dominance pruning (Hall et al.
; Torralba and Hoffmann 2015; Torralba 2017), or symbolic representations (Bryant 1986; Edelkamp and Helmert 1999; Torralba et al. 2017).
In this work, we look into a recent addition to this set of techniques, namely star-topology decoupled state space search, or decoupled search for short (Gnad and Hoffmann 2018).
Decoupled search is a form of factored planning (Amir and Engelhardt 2003; Brafman and Domshlak 2006, 2008;
Fabre et al. 2010) that partitions the variables of a planning task into components such that the causal dependencies between the components form a star topology.
The center C of this topology can interact arbitrarily with the other components, the leaves L =
{ L 1 , . . .
L n } , while any interaction between leaves has to involve the center, too.
A decoupled state s F corresponds to a single center state , an assignment to C , and a non-empty set of leaf states (assignments to an
L i ) for each L i .
The member states of s F , i. e., the set of explicit states it represents, result from all combinations of leaf states across leaf factors, sharing the same center state.
Thereby, a decoupled state represents exponentially many explicit states, leading to a reduction in search effort.
Prior work has shown that there exist scalable families of planning tasks where this reduction is exponentially larger for decoupled search than it is for other state-space-reduction methods like partial-order reduction (Gnad, Hoffmann, and
Wehrle 2019), symmetry breaking (Gnad et al. 2017), symbolic representations (Gnad and Hoffmann 2018), and Petrinet unfolding (Gnad and Hoffmann 2019).
Since decoupled states s F , correspond to sets of states , namely the member states of s F , the standard concept of duplicate elimination, ignoring a state that has already been visited (on a cheaper path) to avoid repeated work, cannot be applied so easily.
More importantly, it is not as effective as in explicit state search, because two decoupled states are only equal if the entire sets of member states they represent are equal.
Therefore, prior work on decoupled search only considered dominance pruning (Torralba et al. 2016;
Gnad and
Hoffmann 2018), where a decoupled state s F 1 that contains the member states S 1 is dominated by a decoupled state s
Fthat represents the set of states S 2 if S 1 ⊆ S 2 , respecting the so-called pricing function of s F 1 and s F 2 in case of optimal planning.
Then, if each member state of s F 2 is reached in s Fwith at most the price
it has in s F 2 , we can safely prune s F 1 , like duplicate states in explicit state search.
Initiating this work was the observation that on average around 60% of the overall runtime of decoupled search for optimal planning is spent on dominance checking (on the benchmarks from our evaluation that are solved in ≥ 0 .
1 s ).
Thus, we take a closer look at (1) algorithmic improvements that lead to an increased pruning power for optimal planning, and (2) ways to make the dominance check more efﬁcient in general.
Regarding (1), we introduce two new extensions to the dominance check.
First, we take into account not only the pricing function, but incorporate the g -value of A ∗ in the check.
Second, we propose a decoupled-state transformation that moves cost from the pricing function into the g -value.
Both make the dominance check more informed, without introducing a computational overhead.
For (2), we experiment with an implementation of exact duplicate checking, which, albeit resulting in weaker pruning, can be beneﬁcial runtime-wise due to the use of hashing; we identify cases where leaves can be skipped in the check, namely if their leaf state space is invertible; and, exploiting the transitivity of the dominance relation, we only check against the nondominated subset of visited decoupled states.
In our experimental evaluation, we see that the improvements as of (2) indeed have a (mostly mild) positive impact on the runtime.
The stronger pruning variants from (1) lead to a substantial reduction in search effort, which translates to a strong runtime advantage.
Background
We consider a classical planning framework with ﬁnitedomain state variables (B¨ackstr¨om and Nebel 1995; Helmert 2006).
In this framework a planning task is a tuple Π =
(cid:104)V , A , I, G (cid:105) , where V is a ﬁnite set of variables , each variable v ∈ V is associated with a ﬁnite domain D ( v ) .
A is a ﬁnite set of actions , each a ∈ A being a triple (cid:104) pre ( a ) , eﬀ ( a ) , cost ( a ) (cid:105) of precondition , effect , and cost .
The preconditions pre ( a ) and effects eﬀ ( a ) are partial assignments to V , and the cost is a non-negative real number cost ( a ) ∈ R 0+ .
A state is a complete assignment to V , I is the initial state , and the goal G is a partial assignment to
V .
For a partial assignment p , we denote by vars ( p ) ⊆
V the subset of variables on which p is deﬁned.
For V (cid:48) ⊆
V , by p [ V (cid:48) ] we denote the restriction of p onto V (cid:48)
∩ vars ( p ) , i. e., the assignment to V (cid:48) made by p .
We identify (partial) variable assignments with sets of variable/value pairs.
An action a is applicable in state s if pre ( a ) ⊆ s .
Applying a in a (partial) state s changes the value of all v ∈ vars ( eﬀ ( a ))
∩ vars ( s ) to eﬀ ( a )[ v ] , and leaves s unchanged elsewhere.
The outcome state is denoted s (cid:74) a (cid:75) .
A plan for Π is an action sequence π iteratively applicable in I , and resulting in a state s G where G ⊆ s G .
A plan π is optimal if the summed-up cost of its actions, denoted cost ( π ) , is minimal among all plans for Π .
During an A ∗ search, we denote by g ( s ) the minimum cost of a path on which a state s was reached from I .
Note that the g -value of a state can get reduced during the search, in case a cheaper path from I to s is generated.
Decoupled Search
Decoupled search is a technique developed to avoid the combinatorial explosion of having to enumerate all possible variable assignments of causally independent parts of a planning task.
It does so by partitioning the state variables into a factoring F , whose elements are called factors .
By imposing a structural requirement on the interaction between these factors, namely a star topology , decoupled search can efﬁciently handle cross-factor dependencies.
A star factoring is one that has a center C ∈ F that interacts arbitrarily with the other factors L ∈ L :=
F \ C , called leaves , but where the only interaction between leaves is via the center.
Actions affecting C , i. e., with an effect on a variable in C , are called center actions , denoted A C , and those affecting a leaf are called leaf actions , denoted A L .
The actions that affect a particular leaf L ∈ L are denoted A L .
1 A sequence of center actions applicable in I in the projection onto C is a center path , a sequence of leaf actions affecting L , applicable in I in the projection onto L , is a leaf path .
A complete assignment to C , respectively an L ∈ L , is called a cen- ter state , respectively leaf state .
The set of all leaf states is denoted S L , and that of a particular leaf L is denoted S L .
A decoupled state s F is a pair (cid:104) center ( s F ) , prices ( s F ) (cid:105) , where center ( s F ) is a center state, and prices ( s F ) : S L (cid:55)→ R 0+ ∪ {∞} is the pricing function , that assigns every leaf state a non-negative price.
The pricing function is maintained during decoupled search in a way so that the price of a leaf state s L is the cost of a cheapest leaf path that ends in s L and that is compliant , i. e., that can be scheduled alongside the center path executed up to s F .
By S F we denote the set of all decoupled states.
We say that a decoupled state s F satisﬁes a condition p , denoted s F | = p , iff (i) p [ C ] ⊆ center ( s F ) and (ii) for every L ∈ L there exists an s L ∈ S L s.t.
p [ L ] ⊆
s L and prices ( s F )
[ s L ] < ∞ .
We deﬁne the set of leaf actions enabled by a center state s C as
A
[Equation]
The initial decoupled state s F 0 is deﬁned as s F:= (cid:104) center ( s F 0 ) , prices ( s F 0 ) (cid:105) , where center ( s F 0 ) =
I [ C ] .
Its pricing function is given, for each L ∈
L , as prices ( s F 0 )
[ s L 0 ] = 0 , where s L 0 =
I [ L ] ; and elsewhere as prices ( s F 0 )
[ s L ] =
c s F 0 ( s L 0 , s L ) , where c s F 0 ( s L 0 , s L ) is the cost of a cheapest path of A L | center ( s F 0 )
\ A C actions from s L 0 to s L .
If no such path exists c s F
( s L 0 , s L ) = ∞ .
The set of decoupled goal states is S F G :=
{ s F G | s F G | = G } .
Decoupled-state transitions are induced only by center actions, where a center action a C is applicable in a decoupled state s F if s F | = pre ( a C ) .
By S La C ( s F ) we deﬁne the set of leaf states of L in s F that comply with the leaf precondition of a C , i. e., S La C ( s F ) :
= { s L | pre ( a C )
[ L ] ⊆
s L ∧ prices ( s F )[ s L ] < ∞} .
Applying a C to s F results in the decoupled state t F = s F (cid:74) a C (cid:75) as follows: center ( t F ) =
center ( s F ) (cid:74) a C (cid:75) , and prices ( t F )[ t L ] = min s L ∈ S LaC ( s F ) ( prices ( s F )
[ s L ] + c t F ( u L , t L )) , where s L (cid:74) a C (cid:75) =
u L .
By π C ( s F ) we denote the center path that starts in s Fand ends in s F .
Accordingly, we deﬁne the g -value of s F as g ( s F ) =
cost ( π C ( s F )) , the cost of its center path.
A decoupled state s F represents a set of explicit states, which takes the form of a hypercube whose dimensions are the leaf factors L .
Hypercubes are deﬁned as follows: actions can be center and leaf action at the same time, so possibly A L ∩ A C (cid:54) = ∅ .
Deﬁnition 1 (Hypercube) Let Π be a planning task, and
F a star factoring.
Then a state s of Π is a member state of a decoupled state s F ,
if s [ C ] = center ( s F ) and, for all leaves L ∈ L , prices ( s F )
[ s [ L ]] < ∞ .
We say that s has price price ( s F , s ) in s F , where price ( s F , s ) :
= (cid:80) L ∈L prices ( s F )
[ s [ L ]] .
The hypercube of s F , denoted [ s F ] , is the set of all member states of s F .
The hypercube of s F captures both, the reachability and the prices of all member states s of s F .
For every member state s of a decoupled state s F , we can construct the global plan , i. e., the sequence of actions that starts in I and ends in s by augmenting π C ( s F ) with cheapest-compliant leaf paths, i. e., leaf action sequences that lead to the pricing function of s F .
The cost of member states in a hypercube only takes into account the cost of the leaf actions, since center action costs are not included in the pricing function.
The cost of a plan reaching a member state s of s F from I can be computed as follows: cost ( s F , s )
=
g ( s F ) + price ( s F , s ) .
Dominance Pruning for Decoupled Search
Prior work on decoupled search has only considered dominance pruning instead of exact duplicate checking (Torralba et al.
Gnad and Hoffmann 2018).
With dominance pruning, instead of duplicate states, the search prunes decoupled states that are dominated by an already visited decoupled state (with lower g -value).
We formally deﬁne the dominance relation (cid:22) B ⊆ S F × S F over decoupled states as ( t F , s F ) ∈(cid:22) B iff (1) [ t F ] ⊆
[ s F ] and (2) for all s L ∈ S L : prices ( s F )[ s L ] ≤ prices ( t F )
[ s L ] .
Instead of ( t F , s F ) ∈(cid:22) B , we often write t F (cid:22) B s F to denote that s
F dominates t F .
Note that (2) is only required for optimal planning.
In satisﬁcing planning we can simply set the price of all reached leaf states to 0 , ignoring the leaf action costs completely.
In practice these checks are performed by ﬁrst comparing the center states center ( s F ) =
center
( t F ) via hashing, followed by a component-wise comparison of the prices of reached leaf states.
Exact Duplicate Checking
In explicit state search, duplicate checking is performed to avoid unnecessary repeated handling of the same state.
This can be implemented efﬁciently by means of hashing functions: if a state is re-visited during search – and, in case of optimal planning using A ∗ , the path on which it is reached is not cheaper than its current g -value – the new state can be pruned safely.
In this section, we will look into exact duplicate checking for decoupled search, showing how an efﬁcient hashing can be implemented.
Formally, we deﬁne the duplicate state relation over decoupled states (cid:22) D ⊆ S F × S F as the identity relation where ( t F , s F ) ∈(cid:22) D iff s F = t F .
Like in explicit state search, a decoupled state t F can safely be pruned if there exists an already visited state s F where g ( s F ) ≤ g ( t F ) and t F (cid:22) D s F .
In decoupled search, a search node, i. e., a decoupled state s F , does not represent a single state, but a set of states, namely its hypercube [ s F ] .
As a consequence, duplicate checking is less effective.
This is because the chances of ﬁnding a decoupled state with the exact same hypercube (including leaf state prices) are smaller than ﬁnding a duplicate in explicit state search.
Importantly, care must be taken when hashing decoupled states, to properly take into account both reachability and prices of leaf states.
In order to hash decoupled states, we need a canonical form that provides a unique representation of a decoupled state.
We achieve this by, prior to the search, constructing all reachable leaf states s L for each leaf L , over-approximating reachability by projecting the task onto L .
This ignores all interaction between the center and the leaf, assuming that action preconditions on V \ L are always achieved.
The re- sulting transition systems are called the leaf state spaces for every leaf L ∈ L .
Given the leaf state spaces, we assign a unique ID to every leaf state, starting with 0 , up to | S LR | − 1 , where S LR is the set of leaf states of L that can be reached from I [ L ] in the leaf state space of L .
With the leaf state IDs, we can efﬁciently store the pricing function of each leaf L ∈ L of a decoupled state s F as an array A of numbers, where A [ i ] contains the price of the leaf state with ID i .
To get a canonical representation of s F , and to keep the memory footprint of its pricing function as small as possible, we decide to limit the size of the array to just ﬁt the highest ID of a leaf state with ﬁnite price.
Implicitly, all leaf states with a higher ID are not reached in s F and have cost ∞ .
This does incur a memory overhead, in the extreme case wasting | S LR |− 1 entries in the array, if only the leaf state with ID | S LR | − 1 is reached, so the entries for all other leaf states are ∞ .
However, leaf state spaces are mostly “wellbehaved” in the sense that such pathologic behaviour does not usually occur.
In non-optimal planning, where, as previously noted, we do not require the actual leaf state prices, but only reachability information, we only keep a bitvector A for each leaf
L ∈ L , indicating whether the leaf state with ID i is reached if A [ i ] = (cid:62) .
The unique IDs and the maintenance of the pricing function as standard arrays allow the use of hashing functions, where two decoupled states can only be equal if the hashes of their center state, and for each leaf factor, the hashes of the representation of the pricing functions match.
Improved Dominance for Optimal Planning
In this section, we introduce two improvements over the basic dominance relation (cid:22) B for optimal planning.
The ﬁrst one incorporates the g -value of decoupled states into the dominance check when comparing the leaf-state prices.
This increases the potential for pruning, allowing to prune states that have a lower g -value.
The second technique is a decoupled-state transformation that moves part of the leafstate prices into the g -value of a decoupled state, enhancing search guidance by fully accounting for costs that have to be spent to reach the cheapest member state.
Incorporating the g -value in Dominance Checking
In optimal planning, a decoupled state t F can only be pruned with (cid:22) B if there exists an already visited state s F with lower g -value that dominates it.
Doing the dominance check in
[Figure] [Figure]
this way, however, separately considers g -values and pricing function, where these in fact can be combined.
We next show that the g -value difference of two decoupled states can be traded against differences in the pricing function.
To see this, recall the deﬁnition of the cost of a member state s of a decoupled state s F : cost ( s F , s )
=
g ( s F ) +
[Equation]
F
[Equation]
s
[Equation] [Equation]
Instead of only comparing the pricing function to visited states with lower g -value, we can directly compare the costs of the member states to all visited states, independent of their g -values.
Then, a new decoupled state t F can be pruned if there exists a visited state s F s.t.
all member states s of t F have lower cost in s F : ∀ s ∈
[ t F ] : cost ( s F , s ) ≤ cost ( t F , s ) .
If all member states s of a decoupled state t F are contained with lower cost in an already visited decoupled state s F , then analogously to pruning duplicate states with higher gvalue in explicit search, we can safely prune t F .
Consider the example in Figure 1.
Each box represents a decoupled state, and an arrow s Li → 6 indicates that in a state s F we have prices ( s F )
[ s Li ] = 6 .
Say s F is visited and t F is a new state,
where g ( t F ) = 10 and g ( s F )
= 5 .
Further, the prices in all but one leaf factor L of both states are identical.
In leaf L , we have prices ( s F )
[ s L ] =
prices ( t F )[ s L ]+5 , so all leaf states of L in t F are cheaper by a cost of 5 , but s F has a g
-value
that is by 5 lower than that of t F .
With the dominance relation (cid:22) B from prior work, t F cannot be pruned, because its prices are lower than the ones of s F .
However, the cost of all its member states is equal to the cost of the states in s F , so it is actually safe to prune t F .
An important question is how to compute this efﬁciently, i. e., without explicitly enumerating the costs of all member states.
We next show that, similar to (cid:22) B , dominance can be checked component-wise by only considering, for each leaf
L , the leaf state with the highest price difference.
Formally, we deﬁne the g -value aware dominance relation (cid:22) G ⊆ S F × S F as follows:
[Equation]
where S LR = { s
[Equation]
If t F has a higher g -value than s F , but has leaf states with a lower price, then the disadvantage in g -value can be traded against the advantage in leaf state prices.
More concretely, it sufﬁces to sum-up only the maximal price-difference of any leaf state over the leaves.
Thereby, we essentially compare only the member state s ∈ [ t F ] for which the priceadvantage is maximal.
This can be done component-wise, so is efﬁcient to compute.
Indeed, (cid:22) G detects that t F in the above example is dominated and can be pruned.
Theorem 1 Let s F and t F be two decoupled states.
Then t F (cid:22) G s F iff for all s ∈ [ t F ] : cost ( t F , s ) ≥ cost ( s F , s ) .
Proof Sketch: Let s be the member state of t F
where prices ( s F )
[ s [ L ]] − prices ( t F )
[ s [ L ]] is maximal for all L ∈ L .
If prices ( s F , s ) − prices ( t F , s ) ≤ g ( t F ) − g ( s F ) , then this also holds for all other s (
cid:48) ∈
[ t F ] .
With cost ( t F , s (cid:48) )
=
g ( t F ) + prices ( t F , s (cid:48) )
the claim follows.
(cid:3)
The new relation (cid:22) G also tackles more subtle cases, where prices differ in several leaf factors.
We then need to distribute the difference in g -values across the leaf factors, i. e., we cannot use the full difference for each factor.
However, we can even trade lower prices in one leaf by higher prices in another, incorporating these different prices in the g -difference.
Consider the example in Figure 2, which extends the previous example by a leaf factor L (cid:48) where prices
[Equation]
We can then combine the price advantage of +2 in L (cid:48) for s F with its g -advantage +5 to make up for a total price disadvantage of 7 in other leaves, where t F might have lower prices:
[Equation]
In this case, given that s F is visited before t F during search, we can prune t F , although the prices of its leaf states are neither lower-equal, nor higher-equal than the prices of t F .
There is even a difference of cost 2 left that could be used to trade higher prices of s F in another leaf factor.
g-Value Adaptation
We next introduce a canonical form which moves as much of the leaf-state prices into the g -value of a decoupled state as possible.
Assume that, in a decoupled state s F , there exists a leaf L such that all leaf states s L have a minimum nonzero price p , so ∀ s L ∈ S L : prices ( s F )
[ s L ] ≥ p .
Then we can reduce the prices of all these leaf states by p and increase g ( s F ) by p without affecting the cost cost ( s F , s )
[Figure]
of the member states s of s F .
Intuitively, the transformation moves the price that has to be spent to reach the cheapest member state of s F into its g -value, reducing the price of all leaf states accordingly, so that in every leaf L there exists at least one leaf state with price 0 .
See Figure 3 for an example of a decoupled state s F and its canonical representative t F .
The main advantage of adapting the g -value of a decoupled state occurs when executing decoupled search using the
A ∗ algorithm.
Here, on a cost layer f the search usually prioritizes states with lower heuristic value.
By moving cost into the g
-value
we achieve that the heuristic of a decoupled state (which takes into account the pricing function (Gnad and Hoffmann 2018)) can only get lower, aiding A ∗ to focus on more promising states.
A second important effect is that the part of the prices moved into the g -value will always be considered entirely by the search, whereas heuristics (in the extreme case blind search) might not be able to capture all the cost encoded in the pricing function.
Note that the g -value adaptation is independent of the new dominance relation (cid:22) G .
It can have a positive impact on the number of state expansions of (cid:22) G , the base dominance check (cid:22) B , and exact duplicate checking (cid:22) D .
Efﬁcient Implementation
In this section, we propose two optimizations that aim at making the dominance check more efﬁcient.
First, we show that with invertible leaf state spaces the comparison of leaf reachability can be entirely avoided.
Second, we show how to exploit the transitivity of the dominance relation to focus the checking on the relevant subset of decoupled states.
Both optimizations do not affect the pruning behavior.
Invertible Leaf State Spaces
Given the precomputed leaf state spaces as described in the previous section, it is straightforward to compute the connectivity of these graphs.
In particular, we can efﬁciently check if a leaf state space is strongly connected when only considering transitions of leaf actions that do not affect, nor are preconditioned by, the center factor.
Formally, we deﬁne the set of no-center actions of a leaf L as A L ¬ C :
= { a L ∈
A L | vars ( pre ( a ))
∩ C = ∅ ∧ vars ( eﬀ ( a ))
∩ C = ∅} .
Let S LR be the set of L -states that is reachable from
I [ L ] in the projection onto L using all actions A .
Let further S LR | A L ¬ C be the corresponding set using only the nocenter actions A L ¬ C of L .
We say that L is leaf-invertible , if
S LR = S LR | A L ¬ C , i. e., any L -state reachable from I [ L ] can be reached using no-center actions, and the part of the leaf state space induced by S LR and A L ¬ C is strongly connected.
Proposition 1 Let L be leaf-invertible and S LR the set of Lstates reachable from I [ L ] , then in every decoupled state s F reachable from s F 0 , the set of reached L -states in s F is S LR .
Proof: In s F 0 , the claim trivially holds.
Let s F be a (not necessarily direct) successor of s F 0 .
The center action that generates s F can possibly restrict the set of compliant leaf states
S La , and affect the remaining ones, resulting in a set of leaf states that is a subset of S LR .
Since S LR is strongly connected by A L ¬ C , all L -states of S LR have a ﬁnite price in s F .
[Equation]
All decoupled states reached during search can only differ in the leaf-state prices for leaf-invertible factors, but will always have the same set of leaf states reached.
Thus, at least for satisﬁcing planning, these leaves do not need to be compared in the dominance check at all.
For optimal planning, we still need to compare the prices, since these might differ.
Another minor optimization that can be performed with the leaf-invertibility information is successor generation during search.
When computing the center actions that are applicable in a decoupled state, we usually need to check leaf preconditions by looking for a reached leaf state that enables an action.
For leaf-invertible leaf factors, however, this check is no longer needed (even for optimal planning), because the set of reached leaf states remains constant.
We precompute the set of applicable center actions, and skip the check for leaf preconditions on leaf-invertible factors.
Transitivity of the Dominance Relation
In explicit state search, a duplicate state can be pruned if it has already been visited (with a lower g -value).
This can be efﬁciently implemented using a hash table.
In decoupled search with dominance pruning, the corresponding check needs to iterate over all previously visited states (with a lower g -value) that have the same center state, and compare the pricing function.
Instead of iterating over all visited decoupled states, though, we can exploit the transitivity of our dominance relations to focus on the relevant visited states, namely those that are not themselves dominated by another visited state.
Proposition 2 Let V be the set of decoupled state already visited during search and let t F a newly generated decoupled state.
If there exist s F 1 , s F 2 ∈ V such that s F 1 (cid:22) s F 2 , where (cid:22) is a transitive relation over decoupled states, then t F (cid:54)(cid:22) s F 2 implies t F (cid:54)(cid:22) s F 1 .
Clearly, we do not need to check dominance of t F against s F 1 , but only need to compare s F 2 and t F to see if t F can be pruned.
During search, we incrementally compute the set of “dominated visited states” as a side product of the dominance check.
If a new state t F dominates an existing state s F 1 , then either there exists another visited state s F 3 that dominates t F , so it will be pruned, or there is no state yet that dominates t F .
In both cases, s F 1 can be skipped in every future dominance check because there exists another visited state, either s F 3 or t F , that is visited and that dominates it.
Experimental Evaluation
We implemented all proposed methods in the decoupled search planner by Gnad & Hoffmann (2018), which itself builds on the Fast Downward planning system (Helmert
[Table]
Logistics                    34 Miconic          42 135135 135135 135 135 135
NoMystery                    19 OpenSt
PSR                    47 Rovers                    8 Satellite
Tidybot
Transport
Woodwork                    16 Zenotravel
Others
[Table]
We conducted our experiments using the lab python package (Seipp et al. 2017) on all benchmark domains of the International Planning Competition (IPC) from 19982018 in both the optimal and satisﬁcing tracks.
We also run decoupled search to prove planning tasks unsolvable, using the benchmarks of UIPC’16 and Hoffmann, Kissmann, and Torralba (2014).
In all benchmark sets, we eliminated duplicate instances that appeared in several iterations.
For optimal planning, we run blind search and A ∗ with h LM-cut (Helmert and Domshlak 2009); in satisﬁcing planning, we use greedy best-ﬁrst search (GBFS) with the h FF heuristic without preferred operator pruning (Hoffmann and
Nebel 2001); to prove unsolvability, we run A ∗ with the h max heuristic (Bonet and Geffner 2001).
We use the common runtime/memory limits of 30 min/ 4 GiB. The code and experimental data of our evaluation are publicly available (https://doi.org/10.5281/zenodo.4061825).
Decoupled search needs a method that provides a factoring, i. e., that detects a star topology in the causal structure of the input planning task.
We use two basic factoring methods, inverted-fork factorings (IF) – only for satisﬁcing planning – as well as the incident arcs factoring (IA) as described in Gnad, Poser, and Hoffmann (2017).
We expect IF factorings to nicely show the advantage of the more efﬁcient handling of invertible leaf state spaces, since there are several domains that have such state spaces in this case, but not using IA.
IA is the canonical choice since it is fast to compute and ﬁnds good decompositions in many domains.
We use the following naming convention for search conﬁgurations: we distinguish the three dominance relations (cid:22) B , (cid:22) D , and (cid:22) G .
We indicate the g -value adaptation, and the invertibility and transitivity optimizations by adding a
Unsolvability
Satisﬁcing
[Table]
Cavediving
[Table]
superscript g , respectively I and T to the relation symbol, e. g. (cid:22) gTB for a conﬁguration that uses (cid:22) B and has the g - adaptation and the transitivity optimization enabled.
Tables 1 and 2 show coverage data (number of instances solved) for the benchmarks where the factoring methods are able to detect a star factoring.
For optimal planning, Table 1, we see that both (cid:22) G and the g -adaptation individually lead to an increase in coverage across several domains for both blind search and A ∗ with h LM-cut .
There even seems to be a positive correlation, shown by the fact that the combination (cid:22) gG outperforms both its components.
We do not separately evaluate the invertibility optimization, since the only change in the successor generation does not inﬂuence coverage a lot.
Compared to (cid:22) B , (cid:22) IB only differs in coverage by + in Openstacks for blind search.
The main advantage of the (cid:22) ITx conﬁgurations stems from the transitivity optimization.
The duplicate checking conﬁgurations without gadaptation show a signiﬁcant drop in coverage compared to (cid:22) B , so although the checking is computationally more
[Figure]
[Figure] [Figure]
efﬁcient, this does not even out the weaker pruning power.
When enabling the g -adaptation, total coverage gets almost back to the level of (cid:22) B for blind search
[Figure]
and increases by 7 instances for h LM-cut .
Compared to (cid:22) gITB , though, in both search variants (cid:22) gID drops in coverage.
Surprisingly, duplicate checking can solve two Freecell instances that the dominance pruning cannot solve with blind search.
Table 2 has coverage (number of instances solved, resp.
proved unsolvable) results for proving unsolvability and satisﬁcing planning.
We focus on the difference between dominance pruning and duplicate checking, as the invertibility and transitivity optimizations do not have an impact on coverage.
Duplicate checking performs worse in several domains, does not affect coverage across many other domains, but never increases coverage.
So even outside optimal planning, with strong pruning being less crucial, its use does in general not pay off.
The scatter plots in Figure 4 and 5 shed further light on the per-instance runtime and search space size comparison between some optimal planning conﬁgurations.
Figureshows the number of expanded states in the top row and the
[Figure] [Figure]
[Figure]
planning with IA vs. IF.
runtime in the bottom row.
All conﬁgurations use the IA factoring and compare (cid:22) B to (cid:22) gITG , with blind search in the left column and h LM-cut in the right column.
The advantage of the more clever dominance check, the g -adaptation, and our runtime optimizations is obvious, saving up to several orders of magnitude for state expansions and runtime.
Figure 5 illustrates the effect of exact duplicate checking.
The left plot shows the expected increase in search space size, due to the reduced pruning power.
The right plot indicates that where the increase in search space size is small the more efﬁcient computation indeed pays off runtime-wise.
The two dashed lines highlight a difference of a factor of 2 , which can often be gained with duplicate checking.
Figures 6 and 7 show the impact of the transitivity and invertibility optimizations.
The plots show per-instance runtime improvement factors of conﬁguration Y on the y-axis over conﬁguration X on the x-axis, where a y -value of a indicates that the runtime of Y is a times the runtime of X (values below 1 are a speed-up).
The transitivity optimization clearly has a positive impact on runtime, reducing it up to 40% in optimal planning and up to 70% for proving unsolvability.
The invertibility optimization (Figure 7) does not show such a clear picture when using the IA factoring (left plot).
With IF, though, it indeed nicely accelerates the dominance check, as the optimization is applicable more often.
Conclusion
We have taken a closer look at the behavior and implementation details of dominance pruning in decoupled search.
We introduced exact duplicate checking, which, in spite of its weaker pruning, can improve search performance in practice due to higher computational efﬁciency under certain conditions.
Furthermore, we developed two optimizations that make the dominance check more efﬁcient to compute.
Our main contribution are two extensions of dominance pruning for optimal planning, that take the g -value of decoupled states into account.
Both methods are highly beneﬁcial and their combination signiﬁcantly outperforms the baseline, improving the performance of decoupled search across many benchmark domains.
For future work we think it is worthwhile to further investigate dominance pruning for decoupled search.
A combination with the quantitative dominance pruning of Torralba (2017) could for example be interesting.