Event-Based Decompositions for Reasoning about External Change in Planners

An increasing number of planners can handle uncertainty in the domain or in action outcomes. However, less work has addressed building plans when the planner’s world can change independently of the planning agent in an uncertain manner. In this paper, I model this change with external events that concisely represent some aspects of structure in the planner’s domain. This event model is given a formal semantics in terms of a Markov chain, but probabilistic computations from this chain would be intractable in real-world domains. I describe a technique, based on a reachability analysis of a graph built from the events, that allows abstractions of the Markov chain to be built to answer specific queries efficiently. I prove that the technique is correct. I have implemented a planner that uses this technique, and I show an example from a large planning domain. Introduction An increasing number of subgoaling planners can handle uncertainty in the domain or in action outcomes, including (Kushmerick, Hanks, & Weld 1994) and (Haddawy, Doan, & Goodwin 1995). However relatively little work has addressed building plans when the world can change independently of the planning agent in an uncertain manner, although (Blythe 1994) and (Hanks, Madigan, & Gavrin 1995) are examples of work in this area. In this paper I describe a method for representing external change by events that can capture some aspects of structure in the possible changes in the planner’s domain. The events have a similar form to STRIPS actions, allowing a planner to create subgoals whose achievement will affect the probability of occurrence of events beyond its direct control. This is discussed further in (Blythe 1994), while the main focus of this paper is to provide a formal description of the model and demonstrate a technique that allows probabilistic expressions to be computed efficiently. The event model is given a formal semantics in terms of a Markov chain with the same state space as the planning domain, called the “full model”. However, probabilistic computations made from this chain would be very inefficient for real-world domains. In calculating the probability of a particular plan succeeding, one typically only needs to know the values of small subsets of the literals that describe the domain. This is because each individual action usually depends on only a small number of literals. It is therefore very inefficient to compute the probability directly from a model that considers the complete state of the domains and so specifies all the fluents. A crucial issue is then to find ways to decompose the full model into small, abstract models that can be used to answer queries about these subsets of the domain. This problem has been discussed by several groups of researchers, including (Boutilier, Dean, & Hanks 1995) and (Dean & Lin 1995). In this paper I describe an algorithm that takes a subset of the domain literals and produces an abstraction of the full model that can provably be used to compute the same probabilities as the full model for queries involving the subset of literals. I introduce the event graph, which is designed to represent the dependencies among events. Given a subset of literals of interest in the domain, I show how a reachability analysis of the event graph can be used to build abstractions of the full model that will answer queries about the subset efficiently. I sketch a proof, contained in full in (Blythe 1996), that computations in the abstract chains will produce the same answers as in the full model. The event graph can be computed efficiently from the domain description before the planning problem is encountered. I show an example of an implemented planner that uses this technique in a large planning domain, where computation with the full Markov chain that models the events is intractable. The next section provides a formal model of external events for a planner in terms of an algorithm that uses them to build a Markov chain describing change over time in the domain. Then I describe the event graph and the technique for building abstractions of the Markov chain useful for answering specific queries. A proof that this technique is sound is sketched in the appendix to this paper. After describing the event graph I demonstrate an implementation of the technique in a large planning domain. A formal model for actions and events In this section I give a formal description of a representation for actions and events, used to motivate and describe the event graph in the next section. The model is based on (Kushmerick, Hanks, & Weld 1994). The planner in which the event graph approach has been implemented uses From: AIPS 1996 Proceedings. Copyright © 1996, AAAI (www.aaai.org). All rights reserved. exists. While deciding CSP solubility is NP-complete, it is possible to define tractable subclasses by restricting constraint graph structure. For example, some algorithms have runtime exponential in the height of a depth-first search (DFS) tree of the constraint graph (Dechter 1992). We can define a tractable subclass of CSP by restricting attention to those instances that, after arrangement by some specific DFS procedure, have a DFS tree with bounded by some constant. We define constraint graph parameters similar to for reflecting the exponent in the runtime complexity of our restricted learning algorithms. To preserve generality, we state runtime complexity in terms of how many domain values are considered by the algorithm. Specifically, a value is said to be considered whenever the algorithm checks to see whether it instantiates some variable. Runtime can be bounded by multiplying the number of domain values considered with the complexity of verifying an instantiation. Complexity of verifying an instantiation depends on the arity of the constraints (how many variables mentioned by its nogoods) as well as implementation specific factors. Typically if the instance is binary (all constraints are of arity 2), the complexity of verifying an instantiation is . This is because nogoods which map values to the same set of variables can be grouped into a single compatibility matrix to be tested in constant time. Rooted-Tree Arrangements We begin by reviewing the concept of rooted-tree arrangements for improving runtime complexity of backtrack search. We use this result as a starting framework to which various learning schemes will be added and evaluated. A rooted tree is a noncyclic graph whose edges are directed away from the root vertex and towards the leaves. A branch of a rooted tree is a path from the root vertex to some leaf. A rooted-tree arrangement of a graph (Gavril 1977)1 is a rooted tree with the same set of vertices as the original graph and the property that adjacent vertices from the original graph must reside in the same branch of the rooted tree. The concept is illustrated in Figure 1. Directed edges represent a rooted-tree arrangement of the vertices. For illustrative purposes, the original constraint graph edges are displayed as dashed arcs to demonstrate that adjacent vertices appear along the same branch. Backtrack algorithms can exploit rooted-tree arrangements to improve runtime complexity on some instances. Such an algorithm appears in Figure 2. We refer to the working assignment as the set of instantiations made to the current subproblem’s ancestors. The algorithm traverses the 1 It is not clear whether pseudo-tree as defined in (Freuder & Quinn 1985) is equivalent to a rooted-tree arrangement or depth-first search (DFS) tree. Nevertheless, a rooted-tree arrangement is a slight generalization of DFS tree (Bayardo & Miranker 1995), and the results from (Freuder & Quinn 1985) apply to both. h