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 assigns costs to transitions.
A transition cost function is ﬁnite if −∞ < tcf ( t ) < ∞ for all transitions t ∈ T ( T ) .
It is nonnegative if 0 ≤ 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 commutative.
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]
and x ⊕ ( −∞ ) =
−∞ for all x (cid:54) = ∞ .
This operation is associative and commutative.
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
= s i
[Equation]
l i −→ s i is deﬁned as cost
[Equation]
[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 system.
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 induces 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 corresponding 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 functions.
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
[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.
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) .
Let T be a transition system.
A transition cost partitioning for a weighted transition system (cid:104)T , tcf (cid:105) is a tuple (cid:104) tcf 1 , . .
tcf n (cid:105) ∈ C ( T ( T ))
n whose sum is bounded by tcf : n (cid:88) i = tcf i
[Equation]
t ) ≤ tcf [Equation] t ) for all t ∈ T ( T )
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 partitioning 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) .
Let T be a transition system.
An operator cost partitioning for an 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 current state-of-the-art cost partitioned heuristic (Seipp and Helmert 2019) where abstraction heuristics are handled in sequence.
In every iteration, the algorithm is given the next abstraction for which it computes the heuristic estimates using a remaining cost function.
Initially, the remaining cost function is simply the cost function that is given with the planning task.
The cost saturation step then computes the saturated cost function, which assigns the minimal cost function to the abstract transition system that is needed to preserve the abstract goal distances.
Finally, the saturated cost function is subtracted from the remaining cost function to compute the remaining cost function for the next abstraction.
The saturated cost functions form a cost partitioning and the heuristic values can be added up admissibly.
The above procedure is called Saturated Operator Cost Partitioning, if all cost functions are operator cost functions and Saturated Transition
Cost Partitioning if all cost functions are transition cost functions. Observe that every Saturated Operator Cost Partitioning is also a Saturated Transition Cost Partitioning because every operator cost function is a transition cost function.
Due to the greediness of the cost saturation, the procedure is sensitive to the order in which the abstractions are handled because an earlier abstraction might use costs that would be better off spend in a later abstraction.
To weaken this problem, the Saturated Operator Cost Partitioning was recently extended to preserve the heuristic values of only a subset of states that seem most relevant and is called Subset-Saturated (Operator) Cost Partitioning (Seipp and Helmert 2019).
In this chapter we generalize the concepts of SubsetSaturated Operator Cost Partitioning to Subset-Saturated
Transition Cost Partitioning by simply dropping the constraint that saturated cost functions must be operator cost functions and therefore allow them to be transition cost functions.
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 function 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 operator saturator for S (cid:48) and h i for all 1 ≤ i ≤ n .
The operator cost partitioning (cid:104) ocf 1 , . .
. , ocf n (cid:105) of the operator cost function ocf induced by Saturate is deﬁned as: remain 0 = ocf ocf
i = saturate i − 1 ( remain i − 1 ) for all 1 ≤ i ≤ n remain i =
remain i − 1 − ocf
i for all 1 ≤ i ≤ n
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.
Subset-Saturated Transition Cost Partitioning
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 saturator 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
[Equation] ( 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 transition 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 to assign 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) , because
S (cid:48) ⊇ S (cid:48)(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 heuristic 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 admissible heuristic h 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]

[Equation]
[Equation] [Equation] s (cid:48) ) , if h ( tcf , s (cid:48) ) < ∞ −∞ , otherwise
In the case of a nonnegative transition saturator all +t , replace all negative saturated transition costs with 0 .
In the case of a general transition saturator all t , we have to handle inﬁnite and negative costs in the input with the three preprocessing steps described by Seipp and Helmert (2019) as follows.
Firstly, for every transition t with current remaining cost tcf ( t ) = ∞ , we set mstcf ( t ) =
∞ .
It may assign a higher cost to t than necessary, and the resulting saturated transition might not be minimal.
This is not an issue regarding the minimality of the cost function because the remaining cost of ∞ will remain ∞ forever, independently of what we assign to mstcf ( t ) because ∞ − ∞ =
∞ under left addition.
The necessity to use mstcf ( t ) = ∞ comes from the fact that a transition with weight ∞ carries the information of a ”blocking” transition according to the path addition rules.
A transition becomes a ”blocking” transition if a previous abstraction detects that the transition is part of the state space with inﬁnite heuristic values.
Secondly, for every transition t with current remaining cost tcf ( t ) < ∞ that ends in a state with a heuristic value of ∞ , we set mstcf ( t ) =
−∞ because the heuristic value is ∞ independently of the saturated cost for this transition.
Third, for every transition t with current remaining cost tcf ( t ) < ∞ that starts in a state with a heuristic value of −∞ , we set mstcf ( t ) =
−∞ because the heuristic value is preserved by any saturated transition cost that is upper bounded by the input transition cost.
Therefore mstcf ( t ) =
−∞ is an optimal choice because it leaves the most remaining transition cost for later abstractions.
In the case of a general transition saturator, we additionally provide a modiﬁed version all (cid:48) t where we replace saturated transition costs of −∞ with 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.
The drawback is that later abstractions might not ”block” transitions on abstract goal paths (as described in the ﬁrst preprocessing step).
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.
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 afterwards.
In the case of a modiﬁed general transition saturator, apply the modiﬁed general transition saturator all (cid:48) t 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 k
= { s ∈ S ( T ) | h ( tcf , s ) ≤ k } .
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.
We do not consider abstract transitions between abstract states with inﬁnite heuristic value because we can immediately determine their saturated costs as described in the all t preprocessing (Seipp and Helmert 2019).
[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 to minimize the objective of minimizing the sum of used operator costs min (cid:80) l ∈ L ( T ) C l .
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.
[Figure]
Comparison of the spd transition saturator In our ﬁrst experiment, we compare the all t transition saturator against 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
[Figure] [Figure]
10101010perim
[Figure]
p e r i m t , a ll (cid:48)
t
+ a ll (cid:48)
t
Subset-Saturated Operator Cost Partitioning heavily outperforms Subset-Saturated Transition Cost Partitioning in our setup.
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 vari-
[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 all o47 perim
[Figure]
all tall
[Figure]
treach (cid:48)
t    -
[Figure]
- perim
[Figure]
of tasks where r returns a transition cost partitioning with a better initial heuristic value than c .
Boldface is used to indicate the winner in the pairwise comparison ( r, c ) and ( c, r ) .
able reordering techniques on decision diagrams which still remains untouched and open for future work.
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