Subset-Saturated Transition Cost Partitioning for Optimal Classical Planning
Anonymous
Abstract
Cost Partitionings allow additively combining the heuristic estimates of multiple abstractions.
This often gives better heuristic estimates compared to a single abstraction heuris- tic.
Subset-Saturated Cost Partitioning considers the abstraction heuristics in sequence and assigns the minimum fraction of remaining costs that it needs to preserve the heuristic estimates of a subset of states.
We generalize Subset-Saturated Cost Partitioning by taking the context of applied actions into account.
An empirical evaluation shows that the additional computational overhead caused by taking into account the application context of each action often does not pay off in terms of runtime, but leads to more informed heuristics.
Introduction
Heuristic search with a lower bounding heuristic is one of the most promising techniques to solve challenging planning problems optimally.
We consider additive cost partitioned abstraction heuristics that combine information from multiple sources (Katz and Domshlak 2008).
A Cost Partitioning distributes the costs among multiple abstraction heuristics in a way that allows additively combining their heuristic estimates.
Operator Cost Partitionings (Katz and Domshlak 2008) distribute costs over operators.
Transition Cost Partitionings (Keller et al.
2016a; Pommerening et al.
2015) distribute costs over transitions allowing to take the context of applied actions into account.
Seipp and Helmert (2013a) showed that cost saturation is an effective approach to compute cost partitioned abstraction heuristics (Seipp, Keller, and Helmert 2017).
It considers the abstraction heuristics in sequence and assigns the minimum fraction of the remaining costs that it needs to preserve the heuristic estimates.
Recently, Seipp and Helmert (2019) proposed Subset-Saturated (Operator) Cost Partitioning that computes Operator Cost Partitionings and preserves the heuristic estimates of a subset of states that look more important during the search.
Therefore, leaving more remaining costs for later abstractions.
In this work we deﬁne Subset-Saturated Transition Cost
Partitioning, which additionally takes the context of applied actions into account.
We use the Saturated Transition Cost
Partitioning algorithm by Keller et al.
(2016a)
and preserve the heuristic estimates of the same subset of states given by
Seipp and Helmert (2019).
The beneﬁt compared to SubsetSaturated Operator Cost Partitioning is that it never leaves any remaining costs unused.
The drawback of this approach is that it is necessary to store costs of exponentially many transitions which adds decent computational overhead especially when there is no compact representation in the data structure based on decision diagrams (Keller et al. 2016a).
Our empirical evaluation shows that Subset-Saturated
Transition Cost Partitioning computes better heuristic estimates in many tasks.
But compared to Subset-Saturated Operator Cost Partitioning, the computation of heuristics with
Subset-Saturated Transition Cost Partitioning often takes too much time, such that the improvements in heuristic quality do not pay off.
This raises the question for future work whether and how it is possible to obtain more informative heuristics by considering the application context of actions in a way that the gain in heuristic quality pays off in practice.
Background
In this chapter we deﬁne, describe and discuss the concepts and ideas that form the foundation for Subset-Saturated
Transition Cost Partitioning.
Transition Systems
A transition system describes the dynamics of a state-based system.
Transition systems are also called state spaces.
Deﬁnition 1 (Transition System (Seipp and Helmert 2019)) .
A Transition System T is a directed, labeled graph deﬁned by a ﬁnite set of states S ( T ) , a ﬁnite set of labels L ( T ) , a ﬁnite set T ( T ) of labeled transitions s l −→ s with s, s (cid:48) ∈
S ( T ) and l ∈ L ( T ) , an initial state s 0 ( T ) ∈ S ( T ) and a set S (cid:63) ( T ) ⊆
S ( T ) of goal states.
The objective in state space search is to ﬁnd paths from the initial state to a goal state.
Deﬁnition 2 (Paths and Goal Paths (Seipp and Helmert 2019)) .
Let T be a transition system.
A path from s ∈ S ( T ) to s (cid:48) ∈ S ( T ) is a sequence of transitions from T ( T ) of the form
π = (cid:68) s 0 l 1 → s 1 , . . .
, s n − 1 l n −→ s n (cid:69) , where s
=
s and s n = s (cid:48) .
The length of π denoted by | π | , is n .
The empty path (of length 0 ) is permitted if s =
s (cid:48) .
π is called a goal path, if it is a path to any goal state s (cid:48) ∈ S (cid:63) ( T ) .
In the context of Classical Planning and Cost Partitioning, it is convenient to allow assignment of costs to transitions that are not necessarily unit costs.
Transition cost functions allow a different assignment for each transition.
Deﬁnition 3 (Transition Cost Function) .
Let T be a transition system with transitions T ( T ) .
A transition cost function for T is a function tcf : T ( T ) → R ∪ {−∞ , ∞} that as- signs costs to transitions.
A transition cost function is ﬁnite if −∞ < tcf ( t ) < ∞ for all transitions t ∈ T ( T ) .
It is nonnegative if≤ tcf ( t ) for all transitions t ∈ T ( T ) .
We write
C ( T ( T )) for the set of all transition cost functions for
T and C ≥
( T ( T )) for the set of all nonnegative transition cost functions for
T .
We speak of a general transition cost function if the transition cost function is not required to be nonnegative or ﬁnite.
A special case of a transition cost function is an operator cost function (Seipp and Helmert 2019).
It is a transition cost function where every transition with the same label is assigned the same cost value in the considered codomain.
Hence, an operator cost function is a mapping from labels to the considered codomain.
Note that an operator cost function could also be named a label cost function.
Deﬁnition 4 (Operator Cost Function) .
Let T be a transition system with labels L ( T ) .
An operator cost function for T is a function ocf :
L (
T )
→ R ∪ {−∞ , ∞} that assigns costs to labels.
We write
C ( L ( T )) for the set of all operator cost functions for
T and C ≥
( L ( T )) for the set of all nonnegative operator cost functions for
T .
Every operator cost function transforms into a transition cost function by setting the cost of every transition to the cost that is assigned to the label by the given operator cost function.
The inverse transformation does not work because a transition cost function is more expressive than an operator cost function.
Thus, we allow the implicit use of an operator cost function if we speak about a transition cost function.
In the context of Cost Partitioning, it is convenient to work with a collection of transition systems where each transition system is associated with a transition cost function.
The following deﬁnition makes it more convenient to work with such a pairing (Seipp and Helmert 2019).
Deﬁnition 5 (Weighted Transition System) .
A weighted transition system is a tuple (cid:104)T , tcf (cid:105) where T is a transition system and tcf is a transition cost function for
T .
Allowing inﬁnities to be assigned to transitions through either operator or transition cost functions means that we must take care of arithmetic expressions that involve + ∞ and −∞ to make the theory of cost partitioning work.
Seipp and Helmert (2019) deﬁned two kinds of addition which makes it possible to handle mixed inﬁnities in Cost Partitioning.
The symbols + (inﬁx) and (cid:80) (preﬁx) denote the leftaddition operation.
Left-addition over integers is the usual addition.
Expressions that contain inﬁnities are deﬁned as ∞ + x = ∞ and −∞ + x = −∞ for all integers x , including x being ∞ or −∞ .
This operation is associative but not com- mutative.
Intuitively, a left addition sum that contains mixed inﬁnities evaluates to the leftmost inﬁnity.
In Cost Partitioning, we use left-addition for summing up multiple heuristic values and distributed costs (Seipp and Helmert 2019).
The symbols ⊕ (inﬁx) and (cid:76) (preﬁx) denote the pathaddition operation.
Path addition over integers is the usual addition.
Expressions that contain inﬁnites are deﬁned as
[Equation]
⊕ ( −∞ ) =
−∞ for all x (cid:54) = ∞ .
This operation is associative and commuta- tive.
Intuitively, a path addition sum evaluates to + ∞ if the path addition sum involves at least one + ∞ .
We use pathaddition to deﬁne the cost of a path in a transition system (Seipp and Helmert 2019).
Deﬁnition 6 (Cost of a path) .
Let (cid:104)T , tcf (cid:105) be a weighted transition system.
The cost of a path π
= (cid:68)
[Equation]
with t
i
[Equation]
s i
[Equation]
l i −→ s i is deﬁned as cost ( tcf ,
[Equation]
Intuitively, a path of cost −∞ is inﬁnitely cheap, and a path of cost ∞ is non-existent.
In Optimal Classical Planning, we are interested in ﬁnding paths with the cheapest cost to a goal.
The following deﬁnition captures goal distances as functions that depend on a given state and a transition cost function.
This notion follows the pairing of transition systems and transition cost functions in Cost Partitioning.
Deﬁnition 7 (Goal Distances and Optimal Paths (Seipp and
Helmert 2019)) .
Let (cid:104)T , tcf (cid:105) be a weighted transition sys- tem.
The goal distance of a state s ∈ S ( T ) in T under cost function tcf is deﬁned as inf π ∈ Π (cid:63) ( T ,s ) cost ( tcf , π ) where Π (cid:63) ( T , s ) is the set of goal paths from s in T .
We write h ∗T ( tcf , s ) for the goal distance of s in T under transition cost function tcf .
A goal path π from s in T is optimal under the given transition cost function tcf if cost ( tcf , π ) =
h ∗T ( tcf , s ) .
The inﬁmum ensures that repeatedly taking a negative cost cycle in the transition system will evaluate to −∞ .
Planning Tasks
We consider SAS + like planning tasks (B¨ackstr¨om and
Nebel 1995) with state-independent action costs.
A SAS + planning task with state independent costs is a 5 -tuple Π
= (cid:104)V , O , s I , s (cid:63) , c (cid:105) where V is a ﬁnite set of state variables and each variable v has a ﬁnite domain
D v .
Every variable v in- duces a set of facts of the form ( v, d ) where d ∈ D v .
A partial assignment s is a set of facts of different variables.
If s contains a fact for each variable then s is called a state.
The set of all states over variables V is denoted by S ( V ) .
For a state s we write s ( v ) =
d if the state contains the fact ( v, d ) .
A ﬁnite set of operators (or actions)
O where each operator o ∈
O is a tuple o = (cid:104) pre ( o ) , eff ( o ) (cid:105) and pre ( o ) , eff ( o ) are partial assigments.
The set of operators induce a successor function succ : O × S ( V ) → S ( V ) where succ ( o, s ) = s (cid:48) if pre ⊆ s and s (cid:48)
( v ) =
eﬀ ( v ) if eﬀ ( v ) is deﬁned and s (cid:48) ( v ) =
s ( v ) otherwise.
The initial state is s I and the goal condition s (cid:63) is a partial assignment.
The cost of each operator is given by a state-independent cost function c : O → R +0 .
In state space search, we are traversing through the induced weighted transition system of a given planning task starting from the initial state.
The components of the induced weighted transition system (cid:104)T (Π) , ocf (cid:105) for a SAS + planning task with state-independent costs c : O → R + are deﬁned as follows:
The set of states equals the set of all states of Π over V , i.e. S ( T )
=
S ( V ) .
The set of labels equals the set of operators, i.e. L ( T )
= O .
There exists a transition with label l ∈ L ( T ) from state s ∈ S ( T ) to state s (cid:48) ∈ S ( T ) if the operator is applicable in s and its effect transforms s to s (cid:48) , i.e. T ( T ) =
{ s l −→ s (cid:48) | s, s (cid:48)
∈ S ( T )
∧ l ∈ L ( T ) ∧ succ ( l, s ) =
s (cid:48) } .
The initial state of the transition system equals the initial state of the planning task, i.e. s 0 ( T )
=
I .
The set of goal states contains all states that satisfy the goal condition, i.e. S (cid:63) ( T ) = { s ∈ S ( T ) | s ⊇ γ } .
The cost of an operator with label l ∈ L ( T ) equals the cor- responding operator cost, i.e. ocf ( l )
= cost ( l ) for all labels l ∈ L ( T ) .
Abstractions
Abstractions are relaxations of the behavior of a state-based system where multiple states collapse into a single abstract state (Helmert, Haslum, and Hoffmann 2007).
Deﬁnition 8 (Abstraction) .
Let T , T (cid:48) be two transition systems with the same label sets L ( T ) =
L ( T (cid:48) ) and let α :
S ( T ) → S ( T (cid:48) ) , β : T ( T ) → T ( T (cid:48) ) be surjective func- tions.
We say that
T (cid:48) is an abstraction of T with abstraction mappings α, β if (1) α ( s 0 ( T ))
=
s
( T (cid:48) ) , (2)
α
( s (cid:63) ) ∈
S (cid:63) ( T (cid:48) ) for all s (cid:63) ∈ S (cid:63) ( T ) , and (3) α ( s ) l −→ α ( s (cid:48) )
∈ T ( T (cid:48) ) and β ( s l −→ s (cid:48) )
=
α ( s ) l −→ α ( s (cid:48) ) for all s l −→ s (cid:48) ∈ T ( T ) .
We refer to T as the concrete transition system and T (cid:48) as the abstract transition system.
We consider a special type of abstraction where every abstract state is cartesian (Seipp and
Helmert 2013b).
An abstraction heuristic is a function that maps each concrete state to the goal distance of its corresponding abstract state under a given transition cost function.
Goal distances in the abstract transition system require an abstract transition cost function that maps every abstract transition to a value in the codomain.
The abstract transition cost function maps an abstract transition t (cid:48) to the minimal cost of every concrete transition that maps to t (cid:48)
(Keller et al. 2016a).
Deﬁnition 9 (Abstraction heuristic) .
Let (cid:104)T , tcf (cid:105) and (cid:10)
T (cid:48) , tcf (cid:48) (cid:11) be two weighted transition systems.
Let T (cid:48) be an abstraction of T with abstraction mappings α, β .
We say that tcf (cid:48) is the abstract transition cost function of tcf that describes the cost of each abstract transition t (cid:48) ∈
T ( T (cid:48) ) in the abstraction with tcf (cid:48)
( t (cid:48)
[Equation]
The abstraction heuristic of a concrete state s ∈ S ( T ) is the goal distance of the corresponding abstract state
α ( s ) in the abstraction T (cid:48) under the abstract transition cost function tcf (cid:48) , i.e. h ( tcf , s ) =
h ∗T (cid:48)
( tcf (cid:48) , α ( s )) .
The deﬁnition of the abstract transition cost function reveals that the computation of an abstract transition cost involves a minimization over all (exponentially many) transitions of the concrete transition system that are responsible for this abstract transition (Geißer, Keller, and Mattm¨uller 2016).
In the case of cartesian abstractions this minimization of exponentially many concrete transitions can be carried out in time that is often polynomial in the number of variables of the planning task, albeit worst-case exponential (Geißer, Keller, and Mattm¨uller 2016).
A heuristic is admissible if it never overestimates the goal distances in the weighted concrete transition system.
Abstraction heuristics are admissible because every goal path in the abstract transition system corresponds to a goal path in the concrete transition system.
The minimization in the abstract transition cost function ensures that the abstraction heuristic does not overestimate any goal distance (Keller et al. 2016a).
Weusethe A ∗ algorithm with an admissible heuristic to ﬁnd optimal goal paths (Hart, Nilsson, and Raphael 1968).
Cost Partitionings
Cost Partitionings distribute costs among a set of abstractions in a way that allows admissibly adding their heuristic estimates.
Transition Cost Partitioning Transition Cost Partitioning partitions the available cost for each transition individually (Keller et al.
2016a; Pommerening 2017).
This allows assigning a different degree of importance to different regions (or contexts) of the state space in different abstractions.
Deﬁnition 10 (Transition Cost Partitioning) .
A transition cost partitioning for a weighted transition system (cid:104)T , tcf (cid:105) with transition cost function tcf ∈ C ( T ( T )) is a tuple (cid:104) tcf
[Equation]
tcf n
[Equation]
∈
[Equation]
T
[Equation]
T ))
n whose sum is bounded by tcf : n
[Equation]
tcf
[Equation]
for all t ∈
[Equation]
A Transition Cost Partitioning induces a heuristic by associating each transition cost function with an abstraction heuristic and summing up the heuristic estimates of individual states.
The following theorem states that the resulting heuristic is admissible.
Katz and Domshlak (2008) introduced Cost Partitioning that works on nonnegative operator cost functions.
Pommerening et al.
(2015) showed that general operator cost functions can be used for Cost Partitioning and Keller et al.
(2016a) deﬁned general transition cost function for Cost Partitioning.
Finally, Seipp and Helmert (2019) introduced left addition rules to handle mixed inﬁnities, which led to Theorem 1 and shows that cost partitioned abstraction heuristics are admissible.
Theorem 1.
Let T be a transition system with admissible heuristics (cid:104)
h 1 , . .
, h n (cid:105) and a transition cost parti- tioning P ( T (
T ))
= (cid:104) tcf 1 , . .
tcf n (cid:105) ∈ C ( T ( T )) n .
Then h
P ( T ( T ))
( s ) = (cid:80) ni
=1 h i ( tcf i , s ) is an admissible heuristic.
Operator Cost Partitioning Operator Cost Partitioning (Katz and Domshlak 2008) is a special case of Transition
Cost Partitioning (Keller et al. 2016a) that partitions the available costs for each operator individually.
Hence every transition cost function is restricted to be an operator cost function.
Operator Cost Partitioning forms the basis of a state-of-the-art cost partitioned abstraction heuristic (Seipp and Helmert 2019).
Deﬁnition 11 (Operator Cost Partitioning) .
An operator cost partitioning for a weighted transition system (cid:104)T , ocf (cid:105) with operator cost function ocf ∈ C
( L ( T )) is a tuple (cid:104) ocf 1 , . .
ocf n (cid:105) ∈ C
( L ( T ))
n whose sum is bounded by ocf : n (cid:88) i =
ocf
i ( l ) ≤ ocf ( l ) for all l ∈ L ( T )
There are different methods to compute Cost Partitionings.
Algorithms based on cost saturation have shown to perform best on the IPC benchmark set (Seipp, Keller, and
Helmert 2017).
Subset-Saturated Cost Partitioning
Cost saturation is the key technique used in a state-of-theart cost partitioned heuristic (Seipp and Helmert 2019).
The idea of cost saturation is that a heuristic should be assigned just as much of the current remaining costs that it needs to preserve its estimates allowing to assign the remaining costs to other heuristics.
The Saturated Cost Partitioning algorithm considers heuristics sequentially and applies cost saturation on every heuristic and the current remaining cost function.
Finally, the cost functions assigned to each heuristic in the sequence are the saturated cost functions and form a Cost Partitioning.
We speak of the Saturated Operator Cost
Partitioning algorithm (Seipp, Keller, and Helmert 2020) if the procedure only considers operator cost functions and we speak of the Saturated Transition Cost Partitioning algorithm
(Keller et al.
2016a)
if it considers transition cost functions.
Saturated Cost Partitioning is sensitive to the heuristic order because an earlier heuristic might use costs that would be more useful in a later heuristic (Seipp 2017).
SubsetSaturated (Operator) Cost Partitioning (Seipp and Helmert 2019) allows us to preserve the heuristic estimates of a subset of states, leaving more remaining costs for the following abstractions.
Inthischapter, we generalize the concepts of SubsetSaturated Operator Cost Partitioning to Subset-Saturated
Transition Cost Partitioning by dropping the constraint that cost functions must be operator cost functions and therefore allow them to be transition cost functions.
Alternatively speaking, we allow preserving the heuristic estimates of a subset of states in the Saturated Transition Cost Partitioning algorithm.
We begin with generalizing the notion of a dominating operator cost functions (Seipp and Helmert 2019) to transition cost functions.
A transition cost function dominates another transition cost function if it never assigns a higher cost to a transition.
Deﬁnition 12 (Dominating Transition Cost Function) .
Consider two transition cost functions tcf and tcf (cid:48) deﬁned on the same set of transitions.
We say that tcf dominates tcf (cid:48) , in symbols tcf ≤ tcf (cid:48) , if tcf ( t ) ≤ tcf (cid:48) ( t ) for all transitions t .
We say that tcf is the unique minimum of a set of transition cost functions Cost if it dominates all transition cost functions in Cost .
(Not all sets Cost have a unique minimum.)
Dominating transition cost functions already occurred in the brief description of cost saturation, where the saturated cost function is a dominating cost function for the current remaining cost function.
The generalization of a saturated operator cost function for a subset of states (Seipp and Helmert 2019) to transition cost functions is given in the following deﬁnition.
Deﬁnition 13 (Saturated Transition Cost Function) .
Consider a weighted transition system (cid:104)T , tcf (cid:105) , a set of states S (cid:48) ⊆
S ( T ) and a heuristic h for T . A
transition cost func- tion stcf ∈ C ( T ( T )) is saturated for S (cid:48) , h and tcf if
1. stcf ≤ tcf and 2.
h ( stcf , s ) =
h ( tcf , s ) , for all states s ∈ S (cid:48) .
We refer to a saturated transition cost function as a saturated operator cost function to emphasize that it is of its subtype.
Observe that the transition cost function tcf itself is a saturated transition cost function.
Subset-Saturated Operator Cost Partitioning SubsetSaturated Operator Cost Partitioning differs from Saturated
Operator Cost Partitioning by an additional parameterization of an operator saturator that takes as an input an operator cost function, a heuristic and a subset of states of a transition system and outputs a saturated operator cost function for the subset of states (Seipp and Helmert 2019).
Deﬁnition 14 (Operator Saturator) .
Consider a transition system T , a set of states S (cid:48) ⊆
S ( T ) and a heuristic h for T .
An operator saturator for S (cid:48) and h is a partial function saturate : C ( L ( T ))
→ C ( L ( T )) such that whenever saturate ( ocf ) is deﬁned, it is a saturated operator cost function for S (cid:48) , h and ocf .
Deﬁnition 15 (Subset-Saturated Operator Cost Partitioning) .
Consider a weighted transition system (cid:104)T , ocf (cid:105) , a set of states S (cid:48) ⊆
S ( T ) , a nonempty sequence of heuristics
H = (cid:104) h 1 , . .
, h n (cid:105) for T and a sequence Saturate = (cid:104) saturate 1 , . .
, saturate n (cid:105) such that saturate
i is an oper- ator saturator for S (cid:48) and h i for all≤ i ≤ n .
The operator cost partitioning
[Equation]
. , ocf n (cid:105) of the op- erator cost function ocf induced by Saturate is deﬁned as: remain 0 = ocf
[Equation]
remain i − 1 ) for all 1 ≤ i ≤ n remain i = remain i − 1 − ocf
i for all 1 ≤ i ≤ n
The subtraction is deﬁned in terms of left addition with a signed right-hand side a − b := a + ( − b ) .
As soon as the leftover costs are ∞ , it is possible to allocate ∞ to any following cost function (Seipp and Helmert 2019).
For a detailed explanation of a set of operator saturators, we refer to the initial work on Subset-Saturated Operator
Cost Partitioning by Seipp and Helmert (Seipp and Helmert 2019).
We generalize these operator saturators in the following section and provide an additional saturator.
We generalize Saturated Transition Cost Partitioning (Keller et al. 2016a) by allowing saturation for subsets similar to Subset-Saturated Operator Cost Partitioning (Seipp and Helmert 2019).
The generalization can compute better heuristics, but due to the greedy nature of cost saturation, this is not always the case (Keller et al. 2016b).
We begin with generalizing operator saturators from Definition 14 to transition saturators that take as an input a transition cost function, a heuristic and a subset of states and outputs a saturated transition cost function for the subset of states.
Deﬁnition 16 (Transition Saturator) .
Consider a transition system T , a set of states S (cid:48) ⊆
S ( T ) and a heuristic h for T .
A transition saturator for S (cid:48) and h is a partial function saturate : C ( T ( T ))
→ C ( T ( T )) such that whenever saturate ( tcf ) is deﬁned, it is a saturated transition cost function for S (cid:48) , h and tcf .
A transition saturator is general if its domain of deﬁnition is C ( T ( T )) .
It is nonnegative to general (NNG) if its domain of deﬁnition is C ≥
( T ( T )) .
It is nonnegative if its domain of deﬁnition is
C ≥
( T ( T ))
and it only produces transition cost functions in
C ≥
( T ( T )) .
The following deﬁnition generalizes Deﬁnition 15 by exchanging operator saturators with transition saturators.
Deﬁnition 17 (Subset-Saturated Transition Cost Partitioning) .
Consider a weighted transition system (cid:104)T , tcf (cid:105) , a set of states S (cid:48) ⊆
S ( T ) , a nonempty sequence of heuristics
H = (cid:104) h 1 , . .
, h n (cid:105) for T and a sequence Saturate = (cid:104) saturate 1 , . .
, saturate n (cid:105) such that saturate
i is a satura- tor for S (cid:48) ⊆
S ( T ) and h i for all 1 ≤ i ≤ n .
The transition cost partitioning (cid:104) tcf 1 , . .
tcf n (cid:105) of the transition cost function tcf induced by Saturate is deﬁned as: remain 0 = tcf tcf
i = saturate i − remain i − 1 ) for all 1 ≤ i ≤ n
remain
i = remain i − 1 − tcf i for all 1 ≤ i ≤ n
The following theorems generalize the domination results between operator saturators (Seipp and Helmert 2019) to transition saturators.
The ﬁrst theorem generalizes the domination by subsets to transition cost functions.
Theorem 2.
[Domination by Subsets]
For a given transition system T , heuristic h for T and transition cost function tcf ∈ C ( T ( T )) , let STCF ( X ) be the set of saturated tran- sition cost functions for the set of states X ⊆ S ( T ) , h and tcf .
Let S (cid:48)(cid:48) ⊆
S (cid:48) ⊆
S ( T ) .
Then:
For all transition cost functions tcf (cid:48) ∈ STCF ( S (cid:48) ) , there exists a transition cost function
tcf (cid:48)(cid:48) ∈ STCF ( S (cid:48)(cid:48) ) that dominates tcf (cid:48) .
If a transition cost function tcf (cid:48)(cid:48) ∈ STCF ( S (cid:48)(cid:48) ) is the unique minimum of STCF ( S (cid:48)(cid:48) ) , then tcf (cid:48)(cid:48) dominates all transition cost functions in STCF ( S (cid:48) ) .
Proof: Statement 1 follows from Deﬁnition 13 where we allow assigning lower saturated costs to transitions that start at or end at states outside the subset if it does not conﬂict with preserving the heuristic value of states within the subset.
Such transitions may exist exclusively in S (cid:48)(cid:48) , because
S (cid:48)(cid:48) ⊆ S (cid:48) .
Statement 2 follows from Deﬁnition 12 of a unique minimum and the ﬁrst statement.
The second theorem generalizes the domination by composition to transition cost functions.
Theorem 3.
[Domination by Composition] Let saturateand saturate 2 be transition saturators for the same transition system T , state set S (cid:48) ⊆
S ( T ) and heuris- tic h .
Let saturate 12 :
C ( T ( T ))
→ C ( T ( T )) be the composition of these saturators, i.e. saturate 12 ( tcf )
= saturate 2 ( saturate 1 ( tcf )) for all transition cost functions
tcf ∈ C ( T ( T )) .
Then saturate 12 is a transition saturator for
T , S (cid:48) and h , and for all transition cost functions tcf ∈ C ( T ( T )) , saturate 12 ( tcf ) dominates saturate 1 ( tcf ) .
Proof: Follows directly from Deﬁnition 16, where we required the output of a transition saturator to dominate its input.
Theorem 2 and 3 help us in ﬁnding reasonable transition saturators from the set of possible transition saturators.
Seipp and Helmert (2019) described a dominating saturator as being more ”economical” because it leaves more remaining cost for the next abstraction than the saturator that it dominates.
In the rest of this chapter, we deﬁne multiple transition saturators.
Most of them are generalizations of the operator saturators given by Seipp and Helmert (2019).
Transition Saturators
In the deﬁnition of each transition saturator, we consider a weighted concrete transition system (cid:104)T , tcf (cid:105) where tcf describes the current remaining transition cost function and an abstraction heuristic h for (cid:104)T , tcf (cid:105) with underlying weighted abstract transition system (cid:10) T (cid:48) , tcf (cid:48) (cid:11) .
all t
The all t transition saturator preserves the heuristic values of all states and is the one that was considered previously by Keller et al.
(2016a).
It computes the unique minimum saturated transition cost function mstcf by setting the consistency constraint h ( tcf , s ) ≤ h ( tcf , s (cid:48) )
+ mstcf ( t ) tight for all transitions t =
s l −→ s (cid:48) ∈ T ( T ) .
This can be enforced by setting
[Equation]
Seipp, Keller, and Helmert (2020) deﬁned the operator (cid:9) in the context of computing the minimum saturated operator cost function msocf . The operator (cid:9) behaves like the regular subtraction in the ﬁnite case and handles inﬁnities as x (cid:9) y = −∞ iff x = −∞ or y = ∞ and x (cid:9) y = ∞
iff x = ∞ (cid:54) = y or x (cid:54) =
−∞ = y . The proof that mstcf is the minimum saturated transition cost function follows immediately from the proof by Seipp,
Keller, and Helmert (2020) which shows that their deﬁnition of the minimum saturated operator cost function msocf is the minimum among all saturated operator cost functions. Their proof shows that the operator (cid:9) computes the minimum for individual transitions.
In the case of a nonnegative transition saturator all +t , we replace all negative saturated transition costs by 0 .
In the case of an NNG transition saturator, we additionally consider a modiﬁed version all (cid:48) t , which replaces every saturated transition costs of −∞ by 0 .
As a result, less remaining costs are available in later abstractions, but using a saturated cost of 0 requires no computational effort in states with inﬁnite heuristic value.
spd t
The spd t transition saturator is a nonnegative transition saturator and preserves the heuristic values of all states.
Its name is derived from the Shortest Path Discovery (SPD) problem (Szepesv ´ ari 2004) where we are given a transition system T (cid:48) , a function query : T ( T (cid:48) )
→ R +0 ∪ {∞} that returns the cost of a transition.
Initially, the costs of all transitions are unknown but obtainable through the query function.
The objective is to ﬁnd the goal distance for every state s ∈ S ( T (cid:48) ) , such that the number of evaluations of the function query is as small as possible.
The SPD problem occurs in the Saturated Transition Cost
Partitioning algorithm as follows:
In each iteration, the algorithm computes the abstraction heuristic given the next abstraction in sequence and the remaining transition cost function.
The remaining transition cost function is available in the form of a data structure based on decision diagrams (Keller et al.
2016a;
Speck, Geißer, and Mattm ¨ uller 2018a;
Geißer, Keller, and Mattm¨uller 2016).
Deﬁnition 9 shows how to compute the abstract transition cost function from the given transition cost function.
Our experiments have shown that this is a signiﬁcant performance bottleneck.
Thus, lowering the number of computations of abstract transition costs has the potential for improvements.
We use a modiﬁcation of Dijkstra’s algorithm that is a greedy SPD algorithm.
The modiﬁcation assigns the smallest remaining cost of 0 to the abstract transition (and every concrete transition that induces it) if the goal distance of the source state of the currently evaluated abstract transition is already known (Szepesv´ari 2004).
reach t
The reach t transition saturator is a generalization of the reach o operator saturator (Seipp and Helmert 2019).
It preserves the heuristic values of all states that are reachable in a forward search.
The preimage S (cid:48) of all states that are reachable in the abstract transition system overapproximates the set of reachable states.
For every unreachable state s ∈
S ( T ) \ S (cid:48)
we set the heuristic estimate to h ( tcf , s ) =
−∞ because they are never visited in a forward search (Seipp and
Helmert 2019).
In the case of a nonnegative transition saturator reach +t , apply the nonnegative transition saturator all +t on the modiﬁed heuristic values.
In the case of a general transition saturator, apply the transition saturator all t afterward.
In the case of an NNG transition saturator, we additionally consider a modiﬁed version reach (cid:48)
t that applies the all (cid:48) t transition saturator instead.
perim t
The perim t transition saturator is a generalization of the perim o operator saturator (Seipp and Helmert 2019) and preserves the heuristic values of all states that are within a perimeter of k to a goal.
The idea is that it is more important to preserve heuristic values of states that are closer to a goal (e.g., Holte et al., 2004; Torralba, Linares L´opez, and
Borrajo, 2018).
The set of states within perimeter k > 0 is S
[Equation]
In our experiments, we set the heuristic value to k for all states outside of S k and apply the nonnegative all +t transition saturator on the modiﬁed heuristic values.
This allows efﬁcient computation of a saturated transition cost function with the guarantee that the heuristic does not contain negative cost cycles in reachable states (Seipp and Helmert 2019).
We obtain a general transition saturator with an additional composition with the general transition saturator all t .
lp t
The lp t transition saturator is a generalization of the lp o operator saturator (Seipp and Helmert 2019) and preserves the heuristic value of only a single state s ∈ S ( T ) .
The set of possible saturated transition cost functions to pick from does not have a unique minimum.
We use an adapted version of the linear programming formulation of the lp o operator saturator to choose from the set of possible saturated transition cost functions.
The LP uses the same LP-trick to encode the heuristic estimates from the saturated transition cost function.
[Equation]
The variables C t encode the saturated transition cost function, the variables C l encode the saturated operator cost function, and the variables H a encode the heuristic values h ∗T (cid:48) .
We also choose the objective of minimizing the sum of used operator costs min (cid:80) l ∈ L ( T )
C l where we only include labels with ﬁnite saturated operator costs.
This requires a preprocessing, where we ﬁrst compute the saturated transition cost of all transitions that result in either ∞ or −∞
Af- terward, we build the LP to compute the saturated transition cost of the remaining transitions.
We ﬁrst set the heuristic value of every state in the preimage of all abstract states that are unreachable from the abstract state that contains s to −∞ (similar idea as described in reach t ).
Then, we apply mstcf to all transitions t that evaluate to mstcf ( t ) ∈ {−∞ , ∞} .
Finally, we restrict the LP only to contain abstract states with ﬁnite heuristic values together with their incident abstract transitions.
If there is an abstract transition with label l and a constraint of type 2, this label is part of the objective function.
After solving the LP, the saturated transition cost of every remaining transition is extracted from the variable C t of the corresponding abstract transition.
In the case of an NNG transition saturator, we additionally consider a modiﬁed version lp (cid:48) t that, similar to the other primed saturators, replaces every saturated transition cost of −∞ by 0 .
In our experiments, we preserve the heuristic value of the initial state.
Experiments
We implemented all transition saturators into the Fast Downward planning system (Helmert 2006).
Similar to modern symbolic search planners, we utilize decision diagrams for compact representation and computation of sets of states (Kissmann and Edelkamp 2014; Torralba et al. 2014;
Speck,
Geißer, and Mattm ¨ uller 2018b).
More speciﬁcally, we use the CUDD library (Somenzi 1994) for Binary Decision Diagrams to represent and compute transition cost functions.
We conducted experiments with the Downward Lab toolkit (Seipp et al. 2017) on Intel Xeon E5-2650v2 2.60GHz processors with 64GB DDR3 1866MHz ECC registered memory.
Each task was limited to a single core with 4GB of memory and a time limit of 30 minutes.
We consider the same set of abstraction as the initial work on cost saturation with operator saturators (Seipp and Helmert 2019) that consists of all CEGAR abstractions with the goal and landmark diversiﬁcation technique (Seipp and Helmert 2014), the systematic pattern databases (Pommerening, R¨oger, and
Helmert 2013) and the pattern databases found by hillclimbing (Haslum et al.
We order the abstractions using the static greedy order with the scoring function h stolen (Seipp 2017), the best ordering method considered in previous work about operator saturators (Seipp and Helmert 2019).
Our evaluation only considers cost partitionings for the single order optimized for the initial state.
We optimize the order independent of the transition saturator for a fair comparison.
All benchmarks, code and experimental data have been published online 1 .
We write saturate 1 ,saturate 2 for the composition saturate 12 of two saturators where the output of saturate 1 is applied to the input of saturate 2 .
With saturate 1 +saturate 2 we denote that saturate 2 is an additional run of cost saturation on the remaining cost after computing a cost partitioning with saturate 1 .
The saturated transition cost functions of both runs form a cost partitioning.
Hence, summing up the heuristic estimates of both runs yields an admissible heuristic.
Postponing additional runs of cost saturation makes sense if there are potentially unused costs available.
Comparison of the spd transition saturator In our ﬁrst experiment, we compare the all t transition saturator against [Figure] unsolved [Figure]
the spd t , all t transition saturator.
Figure 1 shows that the number of computations of abstract transition weights from the given remaining transition cost function is up to 90 times lower.
The average over all instances is 4 .
3 times lower.
As a result, our following experiments always apply the spd t transition saturator ﬁrst because it allows for faster computation of the abstract transition cost function while preserving the heuristic estimates of all states.
Comparison with operator saturator In our second experiment, we compare perim o ,all o +all o operator saturator 2 that is part of a current state-of-the-art heuristic (Seipp and Helmert 2019), against the transition saturator perim t ,
all (cid:48) t +all (cid:48) t .
The perim t ,all (cid:48) t
+all (cid:48) t transition saturator is the generalized counterpart to the perim o ,all o +all o operator saturator.
Figure 2 shows the comparison with respect to the number of node expansions until the last f -layer.
The transition saturator expands less states in 437 instances, and the opposite holds in 59 instances.
Additionally, the transition saturator ﬁnds perfect heuristic estimates in signiﬁcantly more instances.
InFigure 3, we compare the total time in seconds to ﬁnd an optimal plan for the same saturators.
The operator saturator is faster in 898 tasks where both algorithms ﬁnd an optimal plan.
The opposite is true in 100 cases.
We conclude that
Subset-Saturated Operator Cost Partitioning heavily outperforms Subset-Saturated Transition Cost Partitioning in our
[Figure]
unsolved
[Figure]
p e r i m t , a ll 0 t + a ll 0 t
Comparison of saturators Table 1 shows the pairwise comparison of the initial heuristic estimate for a set of reasonable saturators.
The best previous transition saturator all t gives better heuristic estimates for the initial state than its operator saturator counterpart all o in 332 tasks and worse in 155 tasks.
Our new best transition saturator perim t ,all (cid:48) t
+all (cid:48) t gives better heuristic estimates for the initial state than all o intasks and worse in only 45 tasks.
The primed transition saturators all (cid:48) t gives worse heuristic estimates than its unprimed counterpart all t in onlyinstances but solved 17 more instances.
We obtained similar results for the comparison of other transition saturators with its primed versions.
In any comparison, the total time to compute a Transition Cost Partitioning signiﬁcantly improves when using the primed versions.
In our experiments, compositions that include the perim t transition saturator have shown better results than compositions that do not use it.
Postponing the lp t transition saturator is often useless, because a leading transition saturator does not leave any slack in the consistency constraint, e.g. reach t , lp t returns the same heuristic as reach t without lp t . Future work
Improving worst-case performance by improving the storage of transition cost function can greatly impact performance.
Keller et al.
(2016a) already suggested to use variable reordering techniques on decision diagrams which still remains untouched and open for future work.
[Figure]
a ll o p e r i m o , a ll o + a ll o a ll t a ll (cid:48)
t r eac h (cid:48)
t l p (cid:48)
t p e r i m t , a ll (cid:48) t + a ll (cid:48)
t
[Figure]
[Figure]
[Figure]
[Figure] [Figure] [Figure] [Figure]
Subset-Saturated Transition Cost Partitioning is not effective on large sets of abstractions, especially abstractions with large similarities.
Considering different sets of abstractions with sufﬁciently large diversity could further prune unnecessary overhead.
Subset-Saturated Transition Cost Partitioning is compatible with Subset-Saturated Operator Cost Partitioning, in the sense that we can interleave both algorithms to distinguish the context of applied actions only where it seems most promising.
For example, it makes no sense to distinguish the context of an action that only induces state-changing transitions in at most one abstraction.
Actions that induce many state-changing transitions in many abstractions are more likely to improve the heuristic estimates but can also negatively inﬂuence the performance tradeoff.
We think that identifying these interactions can lead to improvements.
Conclusion
We applied cost saturation for subsets to the Saturated Transition Cost Partitioning algorithm.
We came up with an additional saturator that improves computing heuristic estimates of abstractions from a given transition cost function.
Subset-Saturated Transition Cost Partitioning adds a significant amount of computational overhead because of taking the context of applied actions into account.
Our empirical evaluation shows that this often not pays off regarding the runtime but leads to more informed heuristics