Constraint Resolution in Top-Down State-Space Parallel Decomposition

Motivated by the examples in the last section, we present in this section our proposed top- down state-space constraint-resolution method. We defer to the next section to present our strategy for finding the best guidance heuristic through simplification and generalization.

Algorithm 5 summarizes our proposed top-down state-space search for resolving con- straints among subproblems. It is a heuristic search that selects the most promising state I′

with the best heuristic value and that expands the neighboring states of I′

successors of each state only from an action partition, our approach limits the branching factor in each step.

Input: Problem T = (V, A, I, G) Output: Solution plan

{A1, . . ., AK} := partition actions(T ) (Algorithm 1); 1

{T1, T2, . . ., T } := generate simplified instances(T ) (Algorithm 3); 2

h := identify best heuristic({T1, T2, . . ., T }) (Algorithm 6); 3

open := [I]; closed := [];

4

while open is not empty do

5

I′ _{:= remove next state(h, open);} 6

if I′ _{∈ G then} 7

output solution(); return;

8 end 9 if I′ _{∈ closed then/} 10 T′ := formulate subproblem(T , h, I′ , G′ ); 11

{open, closed} := solve subproblem(T′_{, open, closed) (Alg. 7);} 12

end

13

end

14

Algorithm 5: SGPlan6: top-down state-space search with parallel decomposition

Line 1 partitions an action graph by Algorithm 1 into K disjoint subsets. Lines 2 and 3 then apply Algorithm 3 to generate simplified instances and Algorithm 6 to identify the best guidance heuristic h defined in Definition 6.

Line 4 initializes the open list to be the initial state and the closed list to be empty. Here, the open list is a priority queue of states that have not been fully explored, and a closed list contains those expanded states.

Lines 5-14 is a loop that iteratively expands the states by solving a series of subproblems until it reaches G. Here, a subproblem is a group of states explored by the heuristic search in each iteration of the loop.

Definition 17 Subproblem T ’ = {V, A, I’, G’, k} is a quintuple, where V and A are inher-

ited from original problem T , I′

is the initial state of the subproblem, G’ is the subproblem goal, and k is the selected action partition.

The states explored include I′

(Line 6), as well as all its neighboring states with respect to h and the search strategy. It then tests whether I′ _{satisfies G. If it does, we return the plan found (Line 8). If not and}

I′ _{has not been expanded, we formulate T}′ _{with goal G}′ _{whose components are specific to h}

and T (Line 11).

Lastly, the subproblem solver (Algorithm 7) handles the state exploration of G′

, and updates the open and closed lists (Line 12). The solver computes the heuristic value with respect to h for each newly added node in the open list. Also, it guarantees that no goal state has been placed in the closed list.

In general, heuristic values are obtained by relaxing a subset of the conditions of a planning problem. For example, in common forward state-space searches, the heuristic value of a partial plan is derived by satisfying the constraints while relaxing the problem goal because only an applicable action that does not induce mutual exclusions is to be scheduled. In contrast, partial-order-planning methods start from an abstract plan that satisfies both the initial state and the goal. Therefore, the search is conducted in plan space in order to satisfy those precondition constraints and mutual exclusions. In this sense, their heuristic values are measured by the number of flaws in the partial plan.

In planning problems partitioned by parallel decomposition, their heuristic values can be computed in a similar fashion by relaxing their constraints. However, they cannot be computed by relaxing mutual exclusions because a parallel forward search will switch in- discriminately among action partitions when mutual exclusions among parallel subplans are relaxed.

In our approach, we exploit the fact that the set of goal constraints is usually smaller and less complex than the set of mutual exclusions. To this end, we design a forward heuristics-guided search towards the satisfaction of the goal while maintaining the feasibility of precondition constraints and mutual exclusions. The result is a state-space search, since inconsistencies due to parallel decomposition can only happen on the state trajectory.

in which T is to be evaluated. Of course, actions in the active partition must be directly related to the satisfaction of G. Fortunately, there are usually multiple partitions available, and the task is to merely eliminate those unsuitable ones. Our solution is to order the relaxed plan {a1, a2, . . .} from I′ to G by the ignore-delete-lists heuristic and to select Ak if

a1 ∈ Ak, regardless of the actual heuristic h used in the subproblem solver. From the aspect

of finding exit paths with respect to the ignore-delete-lists heuristic, we observe that we can decrease heuristic value with a1 if we re-achieve the delete effects of a1. Thus, the exit path

must have some action mutual exclusive with a1 and like in the same action partition as a1.

With respect to those unselected action partitions, instead of pruning their actions as in Benders cuts, we prioritize them in such a way that they will not be used unless no action in the selected partition is applicable. The ability to prioritize the partitions and to switch to another reduces the risk of getting stuck in one with worse heuristic values. In general, the search will likely continue in the same partition because the locality structure boosts the accuracy of action selection. The details of this step are presented in Section 3.5.

In short, we have formulated constraint resolution in parallel decomposition as a top-down state-space search. By selecting a proper action partition, we can reduce the branching factor of the search. In the next section, we study the trade-offs in determining the best guidance heuristic function.