dAO-Opt: Simple AND/OR Search For DCOP

The AND/OR search spaces are a powerful concept for search that has been introduced by Nilsson in [146], and subsequently further developed in many other contexts [78,39,131,135]. Recently, Dechter and Mateescu [54] showed how AND/OR graphs can capture search spaces for general graph-ical models that include constraint networks and belief networks. These AND/OR graphs are defined relative to the pseudo-tree of the graphical model.

AND/OR search spaces are a formalization of the idea that search on a pseudotree structure is po-tentially exponentially better than traditional search on linear variable orderings,especially if caching is not allowed. The reason is that when performed on a DFS structure (or more generally, on a pseu-dotree), search can be done in parallel on distinct branches of the tree. This yields search processes that in the worst case are time exponential in the depth of the tree. In contrast, traditional search algorithms

1One can think of this algorithm as working on a pseudochain, rather than on a pseudotree

that operate on linear variable orderings are time exponential in the number of variables. Therefore, it is always beneficial to perform search on DFS trees with low depth as opposed to linear variable orderings.

To see an example of this idea, consider the tree in Figure3.3. It is easy to see that onceX0is instantiated to a value from its domain, what remains is actually a set of two distinct subproblems, independent from each other. Therefore, they can be explored in parallel. The process can be applied recursively (instantiatingX₁as well leaves us with 2 independent subproblems -{X3, X₇, X₈}and {X4, X9, X10}, which depend only onX0andX1, but not on each other). On this particular exam-ple, the worst case complexity is reduced thus fromO(exp(14))(the depth of a linear ordering) to O(exp(4))(the depth of the DFS tree).

Freuder [78], Bayardo and Miranker [13] and recently Dechter and Mateescu [54] describe search algorithms that apply this principle in a centralized setting. In [39] a distributed algorithm for constraint satisfactionis described. This algorithm also traverses an AND/OR search space, for finding a single solution. In the following, we introducedAO-Opt: asimple, synchronized extension of AND/OR search for distributed optimization problems. As with [39],dAO-Optalso performs distributed search on a DFS tree in a depth-first manner, with the difference that it works for optimization problems as well. The formal description ofdAO-Optis presented in Algorithm1.

Again, we start with a pre-established DFS tree. The rootXrstarts the search process by assigning itself a valuevr⁰from its domain, and informing its children about this choice with an EVAL(Xr=vr⁰) message. Each one of the children then picks a value for its variable, passes it down to its children, and so on. EachEVALmessage sent to a childXjof an agentXicontains an assignmentSepjfor each variable inSepj, in order to allowXjto evaluate the constraints it has with all its ancestors (not just with its parent).

When an agentXireceives anEV AL(Sepi)message from its parent, the message includes a full assignment of all variables inSepi. Given this assignment,Xican evaluate those utility func-tions it has with its ancestors which are fully instantiated, for each one of its valuesv_i^j ∈dom(Xi).

In the case of non-binary functions,Xi limits this evaluation to only the functionsin the bucket of Xi [50], i.e. those relations whose scope does not include any ofXi’s descendants; these functions are already fully instantiated, and can be evaluated byXi.² The corresponding costs are denoted by local cost(v^j_i,Sepi),∀vi^j∈dom(Xi):

Definition 8 (Local Cost) ³For each agentXi, we denote by local cost(v^j_i,Sepi) =

r_i∈Xi

ri(v_i^j,Sepi) ,

such thatri is fully instantiated. This is the cost of its utility functions and constraints with its

2The functions which include in their scopeXiand descendants ofXiwill be evaluated byXi’s descendant that is lowest in the DFS tree.

3The local cost as defined here is also called thelabelof the node in [54]

Algorithm 1dAO-opt - distributed AO search for cost minimization.

dAO-opt(X,D,R): each agentXidoes:

Construct DFS tree: execute Alg3; after completion,XiknowsPi, P Pi, Ci, P Ci

procedure EVAL:Xiwaits for EVAL(Sepi) messages fromPi(unless root)

1 when EVAL(Sepi) message received: letSepibe the assignment ofSepi 2 forallvi∈dom(Xi)do

3 cost(vi)←local cost(vi,Sepi)

4 forallXj∈Cido

5 send EVAL(SepX_j) message toXjcontaining the currentSepX_j

6 wait for the COST message reply

7 cost(vi) =cost(vi) +costXj(vi)

8pickv^∗_i s.t.v_i^∗=argminvi∈dom(Xi)(cost(vi))

9ifXiis rootthenv_i^∗is the root’s value in the optimal solution, andcost(v_i^∗)is the optimal cost

10 elsesendCOST(cost(v_i^∗))toPi

ancestors, when these ancestors are assigned the values as inSepi, andXi=v^j_i. If the assignment Xi=v^j_i violates any such constraint, then the cost is infinite:local cost(v^j_i,Sepi) =∞.

WhenEVALmessages have reached the leaves, or in case of a deadend (i.e. when an agent cannot find a value in its domain which is consistent with the assignments of its ancestors), the backtrack process begins. The leaves will cycle through their values, determine the best ones for the current instantiation of their ancestors, and reply with the best cost. A dead-ended agent replies with an infinite cost. Subsequently, whenever an agentXihas received cost messages from all of its children for its current value, it tries the next: it informs the children about its new value assignment, and awaits the cost replies. When all its values are tried, the agent chooses the best one (minimal cost, or maximal utility, depending on whether we do minimization or maximization). The agent then reports the corresponding cost to its parent via aCOSTmessage⁴, and the parent starts cycling through its values, and so on.

When the rootXr has cycled through all its values, and has receivedCOST messages for each one, it can pick the best one. The cost (utility) associated with the root’s best value is the optimal cost (utility) for the whole problem.

Re-deriving solutions for subtrees – extra work in the absence of caching: So far, this process allows only for determining the cost (utility) of the best solution, but not necessarily the solution itself. The reason is that this simple scheme does not do any caching. Therefore, when the root finds out what is its optimal value, and announces it, its children do not know what were their corresponding optimal values, and they will have to re-derive them. Therefore, there is another top-down search phase

4This cost is called thevalueof a node in [54]; we use the termCOSThere to maintain consistency with the most part of the DCOP literature, and to avoid confusion with theVALUEmessages.

initiated by the root, where each agent announces its optimal value, and its children solve again their subtrees in the context of the values taken by their ancestors. Thus, smaller and smaller subtrees are solved again, for the purpose of re-deriving the optimal values of the roots of these subtrees, in the context of the ancestors being already assigned their optimal values. Eventually, the process reaches the leaves, and at this point, all agents are assigned their values from the optimal solution.

Remark 4 The problem of rediscovering the solution is a problem that apparently occurs in all dis-tributedsearch algorithms that do not do full caching. However, this does not occur in a centralized algorithm, as in that case ”the best solution so far“ can be stored, and retrieved at the end of the process. This is another complication that has to be solved in order to have very efficientdistributed search algorithms.

Proposition 4 (dAO-opt complexity) dAO-opt (Algorithm1) requires a number of messages which is exponential in the depth of the DFS tree used. Message size and memory requirements are linear for each agent.

PROOF. Straightforward from the centralized case, as dAO-opt simulates a synchronized AND/OR search in a distributed fashion [54].2

It becomes apparent that it is desirable to find DFS arrangements with low depth, as the worst case complexity of dAO-opt depends on this parameter. We review in Section3.4.2.1some existing heuristics for generating shallow pseudotrees.