Finding optimal satisficing strategies for and-or trees

Many tasks require evaluating a specified Boolean expression @f over a set of probabilistic tests whose costs and success probabilities are each known. A strategy specifies when to perform which test, towards determining the overall outcome of @f. We are interested in finding the strategy with the minimum expected cost. As this task is typically NP-hard-for example, when tests can occur many times within @f, or when there are probabilistic correlations between the test outcomes-we consider those cases in which the tests are probabilistically independent and each appears only once in @f. In such cases, @f can be written as an and-or tree, where each internal node corresponds to either the ''and'' or ''or'' of its children, and each leaf node is a probabilistic test. In this paper we investigate ''probabilistic and-or tree resolution'' (PAOTR), namely the problem of finding optimal strategies for and-or trees. We first consider a depth-first approach: evaluate each penultimate rooted subtree in isolation, replace each such subtree with a single ''mega-test'', and recurse on the resulting reduced tree. We show that the strategies produced by this approach are optimal for and-or trees with depth at most two but can be arbitrarily sub-optimal for deeper trees. Each depth-first strategy can be described by giving the linear relative order in which tests are to be executed, with the understanding that any test whose outcome becomes irrelevant is skipped. The class of linear strategies is strictly larger than depth-first strategies. We show that even the best linear strategy can also be arbitrarily sub-optimal. We next prove that an optimal strategy honors a natural partial order among tests with a common parent node (''leaf-sibling tests''), and use this to produce a dynamic programming algorithm that finds the optimal strategy in time O(d^2(r+1)^d), where r is the maximum number of leaf-siblings and d is the number of leaf-parents; hence, for trees with a bounded number of internal nodes, this run-time is polynomial in the tree size. We also present another special class of and-or trees for which this task takes polynomial time. We close by presenting a number of other plausible approaches to PAOTR, together with counterexamples to show their limitations.