See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/221632974

Exploiting Problem Decomposition in Multi-objective Constraint Optimization

Conference Paper · September 2009

DOI: 10.1007/978-3-642-04244-7_47 · Source: DBLP

CITATIONS READS
28 111

1 author:

Radu Marinescu
IBM
73 PUBLICATIONS 717 CITATIONS

SEE PROFILE

All content following this page was uploaded by Radu Marinescu on 03 September 2014.

The user has requested enhancement of the downloaded file.

 Exploiting Problem Decomposition in Multi-objective
Constraint Optimization

Radu Marinescu

Cork Constraint Computation Centre

University College Cork, Ireland
r.marinescu@4c.ucc.ie

Abstract. Multi-objective optimization is concerned with problems involving

multiple measures of performance which should be optimized simultaneously.
In this paper, we extend AND/OR Branch-and-Bound (AOBB), a well known
search algorithm, from mono-objective to multi-objective optimization. The new
algorithm MO-AOBB exploits efficiently the problem structure by traversing an
AND/OR search tree and uses static and dynamic mini-bucket heuristics to guide
the search. We show that MO-AOBB improves dramatically over the traditional
OR search approach, on various benchmarks for multi-objective optimization.

1 Introduction
A Constraint Optimization Problem (COP) is the minimization (or maximization) of
an objective function subject to a set of constraints on the possible values of a set of
independent decision variables. Many real-world problems involve multiple measures
of performance or objectives which should be optimized simultaneously. In contrast
with single function optimization, the simultaneous optimization of multiple, possi-
bly conflicting, objective functions does not in general admit a single, perfect solution.
Instead, Multi-objective Constraint Optimization Problems (MO-COP) tend to be char-
acterized by a set of alternatives which must be considered equivalent in the absence
of information concerning the relevance of each objective relative to the others. There-
fore, solving a MO-COP is to find the efficient frontier, namely the set of equivalent or
non-dominated costs of the set of feasible solutions.
Most complete algorithms for solving MO-COPs typically fall within one of the fol-
lowing two categories: search and inference. Search-based algorithms (e.g. depth-first
Branch-and-Bound) transform a problem into a set of subproblems by selecting a vari-
able and considering the assignment of each of its domain values. The subproblems are
solved in sequence applying recursively the same transformation rule. These algorithms
are not sensitive to the problem structure, have a time complexity which is exponential
in the number of variables, but can operate in polynomial space. Inference-based algo-
rithms (e.g., variable elimination) are known to be good at exploiting the structural in-
formation encoded in the problem. These methods apply a sequence of transformations
that reduce the problem size, while preserving the solution space of the problem. Their
time and space complexity is exponential in a topological parameter called treewidth
(always less than or equal to the number of variables). Due to their high space require-
ments, when the treewidth is large, the latter methods are often impractical.
 The AND/OR search space for COPs [1] is a relatively new framework for search
that is sensitive to the problem structure, often resulting in substantially improved per-
formance. It is based on a pseudo tree that captures conditional independencies in the
problem, resulting in a search tree exponential in the depth of the pseudo tree, rather
than in the number of variables. The AND/OR Branch-and-Bound (AOBB) is a recent
search algorithm introduced in [2] that traverses depth-first an AND/OR search tree
associated with a single objective COP instance.
In this paper, we extend the AND/OR search tree from mono-objective to multi-
objective optimization. We then present a multi-objective depth-first AND/OR Branch-
and-Bound algorithm (MO-AOBB) for finding the efficient frontier of a MO-COP in-
stance. The efficiency of the proposed algorithm also depends on the accuracy of its
guiding heuristic function. We investigate a class of partitioning-based heuristics which
is based on the multi-objective mini-bucket elimination introduced recently in [3]. The
mini-bucket heuristics can be either pre-compiled or generated dynamically at each
node in the search tree. We evaluate the impact of our advancement on several bench-
marks for MO-COPs, including risk-conscious combinatorial auctions, MAX-SAT-ONE
problem instances, bi-objective weighted vertex cover problems, as well as a set of
MO-COP instances derived from real-world mono-objective COP instances. Our results
show conclusively that the new multi-objective AND/OR Branch-and-Bound algorithm
improves dramatically over state-of-the-art search algorithms traversing the traditional
OR space, in many cases by several orders of magnitude.
The paper is organized as follows. Section 2 provides background on COPs, AND/OR
search trees for COPs as well as on MO-COPs. In Section 3 we extend the AND/OR
search tree from mono-objective to multi-objective optimization. Section 4 presents the
multi-objective AND/OR Branch-and-Bound search algorithm for finding the efficient
frontier of a MO-COP instance. Section 5 is dedicated to our empirical evaluation, while
Section 6 provides concluding remarks and directions of future research.

2 Background
2.1 Mono-objective Constraint Optimization Problems
A Constraint Optimization Problem (COP) is a triple P = hX, D, Fi, where X =
{X1 , ..., Xn } is a set of variables, D = {D1 , ..., Dn } is a set of finite domains and
F = {f1 , ..., fr } is a set of cost functions. Cost functions can be either soft or hard
(constraints). Without loss of generality we assume that hard constraints are represented
as (bi-valued) cost functions. Allowed and forbidden tuples have cost 0 and ∞, respec-
tively. The scope of function fi , denoted scope(fi ) ⊆ X, is the set of arguments of fi .
The goal is to find a complete value assignment to theP variables, x = (x1 , ..., xn ), that
r
minimizes the objective function defined by F(X) = i=1 fi (Yi ), where Yi ⊆ X.
Given a COP instance, its primal graph G has a node for each variable and an edge
connects any two nodes whose variables appear in the scope of the same function. The
induced graph of G relative to an ordering d of its variables is obtained by processing
the nodes in reverse order of d. For each node all its earlier neighbors are connected,
including neighbors connected by previously added edges. The width of a node is the
number of edges connecting it to nodes lower in the ordering. The treewidth of a graph
along d, denoted w∗ (d), is the maximum width of nodes in the induced graph.
2.2 AND/OR Search Trees for COP
The AND/OR search space [1] is a unifying framework for advanced algorithmic schemes
for graphical models, including constraint networks and cost networks. Its main virtue
consists in exploiting independencies between variables during search, which can pro-
vide exponential speedups over traditional structure-blind search methods (called here
OR search). The search space is defined using a backbone pseudo tree [4].
Definition 1 (pseudo tree). Given an undirected graph G = (V, E), a directed rooted
tree T = (V, E ′ ) defined on all its nodes is called a pseudo tree if any edge of G that is
not included in E ′ is a back-arc in T , namely it connects a node to an ancestor in T .
Given a COP instance P = hX, D, Fi, its primal graph G and a pseudo tree T of
G, the associated AND/OR search tree ST (P) has alternating levels of OR and AND
nodes. The OR nodes are labeled Xi and correspond to the variables. The AND nodes
are labeled hXi , xi i (or just xi ) and correspond to value assignments of the variables.
The structure of the AND/OR search tree is based on the underlying pseudo tree T .
The root of the AND/OR search tree is an OR node labeled with the root of T . The
children of an OR node Xi are AND nodes labeled with assignments hXi , xi i that are
consistent with the assignments along the path from the root. The children of an AND
node hXi , xi i are OR nodes labeled with the children of variable Xi in T .
A solution tree T of an AND/OR search tree ST (P) is an AND/OR subtree such
that: (1) it contains the root of ST (P), s; (2) if a non-terminal AND node n ∈ ST (P)
is in T then all of its children are in T ; (3) if a non-terminal OR node n ∈ ST (P) is in
T then exactly one of its children is in T ;
It was shown [4, 5, 1] that given a COP instance and a pseudo tree T of depth m, the
size of the AND/OR search tree based on T is O(n · k m ), where k bounds the domains
of variables. Moreover, a COP having treewidth w∗ has a pseudo tree of depth at most
∗
w∗ · log n, and therefore it has an AND/OR search tree of size O(n · k w ·log n ).

2.3 Multi-objective Constraint Optimization Problems

Let us consider now problems with p objectives. A cost vector (also called a p-vector)
v = (v1 , ..., vp ) is a vector of p components where each vj ∈ R represents the cost with
respect to objective j. A cost vector which has all components equal to 0 is denoted by
{0}. A multi-objective function f is a function that associates a cost vector to each
assignment of its scope. Let v and u be two cost vectors. We say that v dominates u,
denoted by v ≤ u, if ∀j, vj ≤ uj . We say that v < u if v ≤ u and v 6= u. The sum of
cost vectors is the usual point-wise sum.
Let α be a set of cost vectors. We define its non-dominated closure as k α k=
{u ∈ α | ∀v ∈ α, v ≮ u}. A set of cost vectors closed under non-domination is called
frontier. Let α and β be two frontiers. We say that α dominates β, denoted by α ≤ β,
if ∀v ∈ β, ∃u ∈ α s.t. u ≤ v. We say that α < β, if α ≤ β and α 6= β. The sum of
frontiers is α + β =k {w = u + v | u ∈ α, v ∈ β} k.
A Multi-objective Constraint Optimization Problem (MO-COP) is a triple M =
hX, D, Fi, where X = {X1 , ..., Xn }, D = {D1 , ..., Dn } and F = {f1 , ..., fr } are
variables, domains and multi-objective functions, respectively. The sum of functions in
 (a) Bi-objective functions (b) Primal graph

Fig. 1. An example of a MO-COP instance with 2 objectives.

F defines the objective function F. The only difference with respect to mono-objective
COP is that multi-objective functions are used. A solution is a complete assignment
x = (x1 , ..., xn ). A solution x is efficient or Pareto optimal if ∀x′ , F(x′ ) ≮ F(x).
The efficient frontier is the set E = {F(x) | ∀x′ , F(x′ ) ≮ F(x)}. The optimization
task is to compute E, and for each v ∈ E, one (of the possibly many) Pareto optimal
assignment with cost v 1 .
As in the mono-objective case, each MO-COP instance has an associated primal
graph, which is computed in the same way: nodes correspond to the variables and an
arc connects any pair of nodes whose variables belong to the scope of the same function.

Example 1. Figure 1 shows a MO-COP instance with 2 objectives, 5 bi-valued vari-

ables and 8 cost functions. The first objective is defined by functions f1 , f2 and f3 ,
while functions g0 , g1 , g2 , g3 and g4 form the second objective, respectively. The cor-
responding bi-objective functions are given in Figure 1(a). For example, the cost vector
associated with f1 (X0 = 0, X1 = 0, X2 = 0) has two components, 5 and 0, which rep-
resent the costs with respect to the first and second objective, respectively. The primal
graph is shown in Figure 1(b). The problem has three solutions: (00000), (01000) and
(01100) with non-dominated costs (7, 0), (4, 2) and (3, 5), respectively.

3 Weighted AND/OR Search Trees for MO-COP

In this section we extend the AND/OR search tree from mono-objective to multi-objective
optimization. Given a MO-COP instance M = hX, D, Fi and its primal graph G, the
AND/OR search tree ST (M) of M is driven by a pseudo tree T of G, as in the mono-
objective case. The arcs from nodes OR nodes Xi to AND nodes hXi , xi i in ST (M)
are annotated by weights derived from the multi-objective cost functions in F. Each
node n in the weighted search tree is associated with a value v(n) which stands for the
answer to the optimization query restricted to the conditioned subproblem below n.

Definition 2 (weight). The weight w(n, n′ ) of the arc from the OR node n labeled Xi
to the AND node n′ labeled hXi , xi i is a cost vector defined as the sum of all the multi-
objective cost functions whose scope includes Xi and is fully assigned along the path
from the root to hXi , xi i, evaluated at the values along the path.
1
In some cases, E may be too large and must be approximated. In this paper we do not consider
this situation.
 (a) Pseudo tree (b) AND/OR search tree

Fig. 2. AND/OR search tree for the MO-COP instance from Fig. 1.

Definition 3 (value). The value v(n) of a node n in a weighted AND/OR search tree of
a MO-COP instance M = hX, D, Fi with p objectives is defined recursively as follows
(where succ(n) are the children of n):
(1) v(n) = P{0}, if n = hXi , xi i is a terminal AND node;
(2) v(n) = n′ ∈succ(n) v(n′ ), if n = hXi , xi i is an internal AND node;
(3) v(n) =k {(w(n, n′ ) + v(n′ )) | n′ ∈ succ(n)} k, if n = Xi is an OR node.

It is easy to see that the value v(n) of a node in the AND/OR search tree ST (M) is
the set of cost vectors representing the efficient frontier of the subproblem rooted at n,
subject to the current variable instantiation along the path from the root to n. If n is the
root of ST (M), then v(n) is the efficient frontier of the initial problem.

Example 2. Figure 2(b) shows the AND/OR search tree for the MO-COP instance
from Figure 1, relative to the pseudo tree from Figure 2(a). The numbers on the OR-
to-AND arcs are the weights corresponding to the function values. For example, the
weight of the arc from the OR node X2 to its AND child hX2 , 0i, along the path
(X0 , hX0 , 0i, X1 , hX1 , 0i, X2 , hX2 , 0i), is (5, 0) and is obtained by summing the val-
ues of the functions f1 (X0 , X1 , X2) and g2 (X2 ), whose scopes contain X2 and are
fully instantiated along that path. A solution tree that corresponds to the assignment
(X0 = 0, X1 = 1, X2 = 1, X3 = 0, X4 = 0) with cost (3, 5) is highlighted in Figure
2(b). The OR node X2 along the path (X0 , hX0 , 1i, X1 , hX1 , 0i, X2 ) has value (2, 0)
which is the non-dominated closure of the frontier below it, namely {(2, 0), (3, 3)}.

4 Multi-objective AND/OR Branch-and-Bound Search

Multi-objective problems can be solved using a depth-first Branch-and-Bound schema,

which traverses a traditional OR search tree of possible assignments in a depth-first
manner and outputs the efficient frontier E of the problem [6, 7]. The algorithm, called
MO-BB, handles two frontiers, called lower and upper bound frontiers. The upper
bound frontier is the set of cost vectors of the best solutions found so far and is an over-
estimation of the efficient frontier E. During search, MO-BB computes at each visited
node a lower bound frontier [8] of the current subproblem using a heuristic evaluation
function. MO-BB backtracks if the upper bound dominates the lower bound, because it
implies that the current partial assignment cannot lead to any new efficient cost vector.
In this section, we apply the general principles of AND/OR search and extend MO-
BB into a Branch-and-Bound algorithm that explores an AND/OR rather than a regular
OR search tree for finding the efficient frontier of a MO-COP instance. The proposed
algorithm is an extension of the recently introduced single objective AND/OR Branch-
and-Bound (AOBB) algorithm [2] to the multi-objective optimization case. We start by
revisiting the notion of partial solution trees [9] to represent sets of solution trees.
Definition 4 (partial solution tree). A partial solution tree T ′ of an AND/OR search
tree ST (M) is a subtree which: (1) contains the root node s of ST (M); (2) if n is an
OR node in T ′ then it contains one of its AND child nodes in ST (M), and if n is an
AND node it contains all its OR children in ST (M). A node of T ′ is a tip node if it
has no children in T ′ . A tip node of T ′ is either a terminal node (if it has no children in
ST (M)), or a non-terminal node (if it has children in ST (M)).
A partial solution tree may be extended (possibly in several ways) to a full solution
tree. It represents extension(T ′ ), the set of all full solution trees which can extend it.
Clearly, a partial solution tree all of whose tip nodes are terminal is a solution tree.

4.1 Heuristic Lower Bounds on Partial Solution Trees

We next define the notion of heuristic evaluation function of a partial solution tree,
which will be used to guide the AND/OR Branch-and-Bound search. Like in OR search,
we assume a given heuristic evaluation function h(n) associated with each node in the
search tree such that h(n) is an underestimation of the efficient frontier v(n) of the
conditioned subproblem below n.
Definition 5 (heuristic evaluation function). Given a partial solution tree Tn′ rooted
at node n in the AND/OR tree ST (M), the heuristic evaluation function f (Tn′ ), is
defined recursively by: (1) if Tn′ consists of a single node n, then f (Tn′ ) = h(n); (2) if
n is an OR node having the AND child m in Tn′ , then f (Tn′ ) = w(n, m) + f (Tm ′
); (3) if
′ ′
Pk ′
n is an AND node having OR children m1 , ..., mk in Tn , then f (Tn ) = i=1 f (Tm i
).
Clearly, by definition, f (Tn′ ) is a lower bound frontier that underestimates the effi-
cient frontier of the subproblem represented by Tn′ . During search, the algorithm main-
tains also an upper bound frontier ub(s) of the efficient frontier v(s), where s is the
root of the search tree. Given the current partial solution tree Ts′ and if the upper bound
frontier ub(s) dominates the lower bound frontier f (Ts′ ) (i.e., ub(s) ≤ f (Ts′ )), then
searching below the current tip node t of Ts′ is guaranteed not to lead to any new effi-
cient cost vector and, therefore, search below t can be safely halted.

4.2 The Branch-and-Bound Algorithm

The depth-first AND/OR Branch-and-Bound search algorithm, MO-AOBB, that traverses
an AND/OR search tree is described by Algorithm 1. It takes as input a MO-COP in-
stance M = hX, D, Fi with p objectives as well as a pseudo tree T of its primal graph
 Algorithm 1: MO-AOBB
Data: A MO-COP instance M = hX, D, Fi with p objectives, pseudo tree T .
Result: Efficient frontier E of M.
1 create an OR node s labeled X1 // Create and initialize the root node
2 v(s) ← ∅; OP EN ← {s}
3 while OP EN 6= ∅ do
4 n ← top(OP EN ); remove n from OPEN
5 if n is an OR node, labeled Xi then // EXPAND
6 for xi ∈ DXi do
′
7 create an AND node n labeled hXi , xi i
8 v(n′ ) ← {0}; h(n′ ) ← heuristic(n′ )
w(n, n′ ) ←
P
9 f ∈F,X ∈scope(f ) f (asgn(πn ))
i
10 succ(n) ← succ(n) ∪ {n′ }

11 else if n is an AND node, labeled hXi , xi i then

12 let Ts′ be the current partial solution tree
13 if v(s)  f (Ts′ ) then
14 for Xj ∈ childrenT (Xi ) do
15 create an OR node n′ labeled Xj
16 v(n′ ) ← ∅; h(n′ ) ← heuristic(n′ )
17 succ(n) ← succ(n) ∪ {n′ }

18 Add succ(n) on top of OP EN

19 while succ(n) == ∅ do // PROPAGATE
20 let par be the parent of n
21 if n is an OR node, labeled Xi then
22 if Xi == X1 then // Search is complete
23 return v(n)
24 v(par) ← v(par) + v(n)
25 if n is an AND node, labeled hXi , xi i then
26 v(par) ←k v(par) ∪ {(w(par, n) + v(n))} k
27 remove n from succ(par)
28 n ← par

and returns the efficient frontier of M. The fringe of the search is maintained by a stack
called OPEN. The current node is denoted by n, its parent by par, the current path by
πn and its assignment by asgn(πn ). The successors of the current node are denoted by
succ(n), while the children of a variable Xi in T are denoted by childrenT (Xi ).
Each node n in the search tree maintains its current value v(n), which is updated
based on the values of its children. For OR nodes, the current v(n) is an upper bound
frontier on the efficient frontier below n. Initially, v(n) is set to ∅ if n is OR, and {0} if
n is AND, respectively. Procedure heuristic(n) computes the lower bound h(n)
on the efficient frontier of the subproblem below n, conditioned on asgn(πn ).
In the EXPAND step, the current node n is expanded in the usual way, depending
on whether it is an AND or an OR node (lines 5–17). The successors of an OR node
Xi are AND nodes labeled by the domain values xi of Xi . The successors of an AND
node hXi , xi i are OR nodes labeled by the children Xj of Xi in the pseudo tree T . The
algorithm also computes the heuristic evaluation function f (Ts′ ) of the current partial
solution tree Ts′ being explored, based on Definition 5. The search below n is terminated
if the current upper bound frontier v(s) dominates f (Ts′ ) (line 13).
The node values are updated by the PROPAGATE step (lines 19–28). It is triggered
when a node has an empty set of descendants (note that as each successor is evaluated,
it is removed from the set of successors in line 27). This means that all its children have
been evaluated, and their values are already determined. If the current node is the root,
then the search terminates with its value, namely the efficient frontier (line 23). If n
is an OR node, then its parent par is an AND node, and par updates its current value
v(par) by summation with the value of n (line 24). An AND node n propagates its
value to its parent par in a similar way, by the non-dominated closure (lines 25–26).
Finally, the current node n is set to its parent par (line 28), because n was completely
evaluated. Search continues either with a propagation step (if conditions are met) or
with an expansion step. The algorithm can be easily instrumented to also record the
solution trees that correspond to the cost vectors in the efficient frontier. Clearly,
Theorem 1. MO-AOBB is sound and complete for MO-COP. In a problem with a single
objective function (i.e., p = 1), the algorithm MO-AOBB is equivalent to AOBB.
While the time complexity of MO-AOBB is bounded by O(n · exp(m)), the size of
the AND/OR search tree, in practice, the running time of MO-AOBB is expected to be
much better than the worst-case bound because the pruning mechanism via the heuristic
evaluation function will prune unpromising portions of the search space.

4.3 Partitioning-based Lower Bound Heuristics

We now describe briefly two general schemes for generating the heuristic estimates
h(n), based on the multi-objective Mini-Bucket approximation. These schemes are pa-
rameterized by the Mini-Bucket i-bound, thus allowing for a controllable trade-off be-
tween heuristic strength and its computational overhead.
Mini-Bucket Elimination (MBE) [10] is an approximation algorithm designed to avoid
the high time and space complexity of Bucket Elimination (BE) [11], by partition-
ing large buckets into smaller subsets, called mini-buckets, each containing at most
i (called i-bound) distinct variables. The mini-buckets are then processed separately.
The algorithm computes a lower bound (assuming minimization) on the optimal so-
lution to a COP. The complexity is time and space O(exp(i)). More recently, [3] ex-
tended MBE(i) from mono-objective to multi-objective optimization problems, yield-
ing Multi-objective Mini-Bucket Elimination (MO-MBE). Given a MO-COP instance,
MO-MBE(i) outputs not only a lower bound frontier of the efficient frontier, but also
the collection of augmented buckets, which form the basis for the heuristics generated.
Static Mini-Bucket Heuristics In the past, [12, 2] showed that the intermediate func-
tions generated by the MBE(i) can be used to compute a heuristic function that un-
derestimates the minimal extension of the current assignment in both OR and AND/OR
search trees for COP. Here, we extend the idea to multi-objective optimization. Consider
a MO-COP instance M and the ordered set of augmented buckets {B(X1 ), ..., B(Xn )}
generated by MO-MBE(i) along a DFS traversal of the pseudo tree T of M. Given
a node n in the AND/OR search tree relative to T , the static mini-bucket heuristic
function h(n) is computed as follows: (1) if n is an AND node labeled hXj , xj i, then
h(n) is the sum of all intermediate functions that were generated in buckets corre-
sponding to descendants of Xj in T and reside in bucket B(Xj ) or the buckets cor-
responding to the ancestors of Xj in T ; (2) if n is an OR node labeled Xj , then
h(n) =k {(w(n, m) + h(m)) | m ∈ succ(n)} k.
Dynamic Mini-Bucket Heuristics Rather than pre-compiling the mini-bucket heuristic
information, it is possible to generate it dynamically, during search [2, 7]. Specifically,
given the set of buckets {B(X1 ), ..., B(Xn )} ordered along a DFS traversal of T , a
node n in the AND/OR search tree and given the current partial assignment asgn(πn )
along the path to n, the dynamic mini-bucket heuristic function h(n) is computed as fol-
lows: (1) if n is an AND node labeled hXj , xj i, then h(n) is the sum of the intermediate
functions that reside in bucket B(Xj ) and were generated by MO-MBE(i), conditioned
on asgn(πn ), in the buckets corresponding to the descendants of Xj in T ; (2) if n is an
OR node labeled Xj , then h(n) =k {(w(n, m) + h(m)) | m ∈ succ(n)} k. Given an
i-bound, the dynamic mini-bucket heuristic implies a much higher computational over-
head compared with the static version. However, the bounds generated dynamically
may be far more accurate since some of the variables are assigned and will therefore
yield smaller functions and less partitioning.

5 Experiments
To evaluate our multi-objective AND/OR Branch-and-Bound approach we have con-
ducted a number of experiments on several MO-COP problem classes such as bi-objective
combinatorial auction, bi-objective weighted vertex cover problems, MAX-SAT-ONE
problem instances as well as bi-objective Weighted CSPs derived from standard mono-
objective instances. We implemented our algorithms in C++ and carried out all experi-
ments on a 2.4GHz dual quad-core with 8GB of RAM running Linux Ubuntu 8.10.
We considered two classes of depth-first AND/OR Branch-and-Bound search al-
gorithms guided by static and dynamic mini-bucket heuristics. They are denoted by
MO-AOBB+SMB(i) and MO-AOBB+DMB(i), respectively. We compare these algo-
rithms against traditional depth-first OR Branch-and-Bound algorithms with static and
dynamic mini-bucket heuristics, denoted by MO-BB+SMB(i) and MO-BB+DMB(i),
respectively. The parameter i represents the mini-bucket i-bound and controls the ac-
curacy of the heuristic. For reference, we also ran the multi-objective Russian Doll
Search algorithm, denoted by MO-RDS, which was recently introduced in [6]. MO-
RDS explores a traditional OR search tree and extends the well known Russian Doll
Search [13] from mono-objective to multi-objective optimization. Algorithms MO-
BB+DMB(i) and MO-RDS were evaluated extensively in [6, 7] and shown to outper-
form dramatically state-of-the-art algorithms for multi-objective optimization such as
ǫ-constraint based search [14], multi-objective iterative deepening search [3] and multi-
objective bucket elimination [3]. The pseudo trees that guide the AND/OR search algo-
rithms were generated using the min-fill heuristic [2]. All competing OR search algo-
rithms used a static variable ordering which was derived from the pseudo tree as well.
In all our experiments we report the CPU time in seconds and the number of nodes
visited for solving the problems. We also specify the problems’ parameters such as the
number of variables (n), maximum domain size (k), the number of cost functions (c),
the depth of the pseudo tree (h) and the treewidth of the graph (w∗ ). In addition, we
also record the size of the efficient frontier found (|E|). The best performance points are
highlighted in each table. A ”-” stands for exceeding the time limit.
Bi-objective Weighted Vertex Cover Given a graph G = (V, E), a vertex cover is a
subset of vertices S ⊆ V such that ∀(u, v) ∈ E, either u ∈ S or v ∈ S. The minimum
 MO-BB+SMB(i) MO-BB+SMB(i) MO-BB+SMB(i) MO-BB+SMB(i) MO-BB+SMB(i)
(V, E) MO-AOBB+SMB(i) MO-AOBB+SMB(i) MO-AOBB+SMB(i) MO-AOBB+SMB(i) MO-AOBB+SMB(i)
(w*, h) MO-RDS MO-BB+DMB(i) MO-BB+DMB(i) MO-BB+DMB(i) MO-BB+DMB(i) MO-BB+DMB(i)
|E| MO-AOBB+DMB(i) MO-AOBB+DMB(i) MO-AOBB+DMB(i) MO-AOBB+DMB(i) MO-AOBB+DMB(i)
i=2 i=4 i=6 i=8 i=10
time nodes time nodes time nodes time nodes time nodes time nodes
sparse
(60, 100) - - - - - - - - - -
(10, 19) 13.27 109,182 14.10 53,051 3.39 49,877 3.28 49,317 3.27 49,104
14 108.74 12,774,381 - - - - - - - - - -
6.25 52,984 5.78 49,149 6.23 49,081 6.80 49,076 7.13 49,076
(70, 120) - - - - - - - - - -
(12, 22) 41.74 253,516 10.87 119,060 7.69 106,561 7.15 104,145 6.98 103,529
16 1560.06 224,998,226 - - - - - - - - - -
14.80 112,891 12.60 103,527 13.44 103,275 14.83 103,246 16.21 103,242
(80, 140) - - - - - - - - - -
(14, 26) 444.19 2,466,147 74.70 747,408 57.01 689,606 52.33 675,044 51.40 672,451
17 - - - - - - - - - - - -
103.91 735,773 83.71 671,259 85.34 669,980 91.02 698,885 96.33 698,860
(90, 160) - - - - - - - - - -
(16, 27) 1815.14 6,047,711 112.88 731,474 58.93 568,307 51.77 551,728 46.09 536,089
29 - - - - - - - - - - - -
169.56 704,192 84.37 533,688 90.17 532,051 100.80 531,590 118.75 531,519
medium
(30, 90) - - - - - - - - - -
(11, 19) 18.56 356,178 17.76 353,469 17.43 351,828 17.27 351,304 17.27 351,098
6 0.05 8,314 - - - - - - - - - -
21.89 351,295 24.18 351,081 25.39 351,039 26.17 351,027 26.76 351,026
(40, 120) - - - - - - - - - -
(14, 23) 139.99 2,312,847 133.06 2,291,297 130.34 2,277,972 129.44 2,274,436 128.74 2,271,194
10 0.97 113,751 - - - - - - - - - -
158.00 2,271,245 173.75 2,269,975 179.67 2,269,844 184.42 2,269,771 189.31 2,269,739
(50, 150) - - - - - - - - - -
(18, 27) 1356.05 19,902,899 1386.05 20,737,676 1306.88 19,962,033 1305.10 19,906,542 1303.90 19,874,904
8 21.56 2,252,573 - - - - - - - - - -
1415.91 18,386,161 1455.62 17,863,968 1469.87 17,559,896 1485.19 17,484,973 1499.06 17,414,634
(60, 180) - - - - - - - - - -
(21, 32) 3116.71 42,000,631 3054.23 41,731,445 3037.54 41,831,396 3031.55 41,834,376 3028.49 41,689,599
12 296.14 21,624,533 - - - - - - - - - -
3112.38 36,825,713 3122.18 34,713,221 3129.76 34,158,428 3138.68 33,822,995 3148.01 33,801,126

Table 1. Result for bi-objective weighted vertex cover problems using static and dynamic mini-
bucket heuristics. Time limit 1 hour. Overall best performance points are boxed.

vertex cover is a vertex cover of minimum size. In the weighted version every vertex v
has an associated weight w(v)
P and the weighted minimum vertex cover is a vertex cover
S with minimum F (S) = v∈S w(v). In the bi-objective version, each vertex v has
two weights w1 (v) and w2 (v) and the task is to minimize the two associated objective
functions simultaneously [3].
We generated random graphs with parameters (V, E, C), where V is the number
of vertices, E is the number of edges and C is the maximum weight, as suggested in
[3]. Instances were generated by randomly selecting E edges. The two weights asso-
ciated with each vertex were generated uniformly at random between 0 and C. Table
1 reports the results obtained on two classes of random graphs: sparse (with V ∈
{60, 70, 80, 90} and E ∈ {100, 120, 140, 160}), and medium (with V ∈ {30, 40, 50, 60}
and C ∈ {90, 120, 150, 180}), respectively. In both cases we set C = 30. The columns
are indexed by the mini-bucket i-bound and the table entries represent an average over
10 random instances generated for each parameter configuration.
When looking at the algorithms guided by mini-bucket heuristics, we observe that
both MO-AOBB+SMB(i) and MO-AOBB+DMB(i) outperformed dramatically the cor-
responding OR Branch-and-Bound algorithms MO-BB+SMB(i) and MO-BB+DMB(i),
across all reported i-bounds. For example, on sparse graphs of size (60,100), MO-
AOBB+SMB(10) solved all instances in about 3 seconds, while MO-BB+SMB(10) ex-
ceeded the 1 hour time limit. In terms of the quality of the heuristic, we also see that
static mini-buckets with a relatively large i-bound represent the best choice. However,
 paths - 30 goods - static mini-bucket heuristics [time] paths - 30 goods - static mini-bucket heuristics [nodes]
4,000 1e+09
MO-BB+SMB(2)
MO-AOBB+SMB(2)
MO-BB+SMB(8) 1e+08
MO-AOBB+SMB(8)
3,000 MO-BB+SMB(14)
1e+07
MO-AOBB+SMB(14)
MO-RDS
time (sec)

1e+06

nodes
2,000 MO-BB+SMB(2)
1e+05 MO-AOBB+SMB(2)
MO-BB+SMB(8)
MO-AOBB+SMB(8)
1e+04
1,000 MO-BB+SMB(14)
MO-AOBB+SMB(14)
1,000 MO-RDS

0 100
20 40 60 80 100 120 140 160 20 40 60 80 100 120 140 160
bids bids

paths - 30 goods - dynamic mini-bucket heuristics [time] paths - 30 goods - dynamic mini-bucket heuristics [nodes]
4,000 1e+09
MO-BB+DMB(2) MO-BB+DMB(2)
MO-AOBB+DMB(2) MO-AOBB+DMB(2)
3,500 1e+08 MO-BB+DMB(8)
MO-BB+DMB(8)
MO-AOBB+DMB(8) MO-AOBB+DMB(8)
3,000 MO-BB+DMB(14) MO-BB+DMB(14)
1e+07
MO-AOBB+DMB(14) MO-AOBB+DMB(14)
2,500 MO-RDS MO-RDS
time (sec)

1e+06

nodes
2,000
1e+05
1,500

1e+04
1,000

500 1,000

0 100
20 40 60 80 100 120 140 160 20 40 60 80 100 120 140 160
bids bids

Fig. 3. Results for bi-objective combinatorial auctions with 30 goods and increasing number of
bids. CPU time and nodes visited using static (top) and dynamic (bottom) mini-bucket heuristics.
Time limit 1 hour. Average treewidth w∗ ∈ [8, 53], average pseudo tree depth h ∈ [16, 88].

if larger i-bounds are not possible, dynamic mini-buckets with small i-bounds are pre-
ferred, especially on sparse problems. For problems from the medium class, MO-
RDS proved to be cost effective with respect to the mini-bucket based algorithms.

Bi-objective Combinatorial Auctions In combinatorial auctions, an auctioneer has a set

of goods to sell and the buyers submit a set of bids on indivisible subsets of goods [15].
In risk-conscious auctions, the auctioneer wants also to control the risk of not being
paid after a bid has been accepted, because it may cause large losses in revenue [16].
Let M = {1, ..., n} be the set of goods to be auctioned and let B = {B1 , ..., Bm } be
the set of bids. A bid Bj is defined by a triple (Sj , pj , rj ), where Sj ⊆ M , pj is the bid
price and rj is the probability of failure, respectively. The auctioneer must decide which
bids to accept under the constraint that each good is allocated to at most one bid. The
first objective is to maximize the auctioneer profit. The second objective is to minimize
risk. Assuming independence, after a logarithmic transformation of probabilities, this
objective can also be expressed as an additive function [7].
For our purpose, we generated mono-objective auctions from the paths distribu-
tion of the CATS suite [15] and randomly added failure probabilities to the bids in the
range 0 to 1. Figure 3 summarizes the results obtained on randomly generated auctions
with 30 goods and increasing number of bids (each data point represents an average
over 10 random instances). These problem instances tend to become highly connected
as the number of bids increases. The average treewidth ranged between 8 (for 30 bids)
and 53 (for 150 bids), while the average pseudo tree depth was between 16 (for 30
 paths 30 goods 80 bids - [w*=25, h=50] - (time) paths 30 goods 80 bids - [w*=25, h=50] - (nodes)
1e+05 1e+08
MO-BB+SMB(i)
MO-AOBB+SMB(i)
MO-BB+DMB(i) MO-BB+SMB(i)
MO-AOBB+DMB(i) 1e+07 MO-AOBB+SMB(i)
1e+04 MO-RDS MO-BB+DMB(i)
MO-AOBB+DMB(i)
MO-RDS
1e+06
time (sec)

nodes
1,000

1e+05

100
1e+04

10 1,000
0 2 4 6 8 10 12 14 16 18 20 0 2 4 6 8 10 12 14 16 18 20
i-bound i-bound

Fig. 4. Impact of the i-bound on bi-objective combinatorial auctions with 30 goods and 80 bids
using static and dynamic mini-bucket heuristics. CPU time (left) and nodes visited (right). Aver-
age treewidth w∗ = 25, average pseudo tree depth h = 50.

bids) and 88 (for 150 bids), respectively. We report on three values of the mini-bucket
i-bound, namely i = 2, i = 8 and i = 14, respectively.
We see that MO-AOBB+SMB(i) is better than MO-BB+SMB(i) at relatively small
i-bounds when the heuristic is weak. This demonstrates the benefit of AND/OR versus
classical OR search when the heuristic estimates are relatively weak and the algorithms
rely primarily on search rather than pruning via the heuristic evaluation function. For
example, on auctions with 60 bids, the average running time of MO-AOBB+SMB(2)
was about 17 seconds, while MO-BB+SMB(2) took on average 1,951 seconds. As the i-
bound increases and the corresponding heuristics are strong enough to prune the search
space substantially, the difference between AND/OR and OR search decreases. When
focusing on dynamic mini-bucket heuristics, we see that MO-AOBB+DMB(i) is bet-
ter than MO-BB+DMB(i) at relatively small i-bounds, but the difference is not that
prominent as in the static case. This is because these heuristics are far more accurate
compared with the pre-compiled ones and the savings in number of nodes caused by
traversing the AND/OR search tree do not translate into additional time savings. On
this domain, we see that MO-AOBB+SMB(i) with relatively large i-bounds outper-
formed MO-RDS. However, MO-RDS was superior to MO-AOBB+DMB(i), except
for the smallest reported i-bound, in which case MO-AOBB+DMB(2) was competi-
tive. The better performance of MO-RDS relative to the AND/OR algorithms can be
explained by a reduced computational overhead for generating its guiding heuristic.
Figure 4 plots the running time and number of nodes visited by MO-AOBB+SMB(i)
and MO-AOBB+DMB(i) (resp. MO-BB+SMB(i) and MO-BB+DMB(i)), on auctions
with 30 goods and 80 bids. Focusing on MO-AOBB+SMB(i), for example, we see that
its running time, as a function of i, forms a U-shaped curve. At first (i = 2) it is high,
then as the i-bound increases the total time decreases (when i = 12 the time is 14.01),
but then as i increases further the time starts to increase again. The same behavior can
be observed in the case of MO-AOBB+DMB(i) as well.

MAX-SAT-ONE Instances Let F be a Boolean formula in conjunctive normal form

(CNF). MAX-SAT is the problem of finding a truth assignment such that the number
of satisfied clauses in F is maximized. MAX-ONE is the problem of finding a model
for F with a maximum number of variables assigned to true. MAX-SAT-ONE is the
 MO-BB+SMB(i) MO-BB+SMB(i) MO-BB+SMB(i) MO-BB+SMB(i)
instance MO-AOBB+SMB(i) MO-AOBB+SMB(i) MO-AOBB+SMB(i) MO-AOBB+SMB(i)
(n, c, k) MO-RDS MO-BB+DMB(i) MO-BB+DMB(i) MO-BB+DMB(i) MO-BB+DMB(i)
(w*, h) MO-AOBB+DMB(i) MO-AOBB+DMB(i) MO-AOBB+DMB(i) MO-AOBB+DMB(i)
|E| i=6 i=8 i=10 i=12
time nodes time nodes time nodes time nodes time nodes
aim-50-1-6no-1 - - - - 14.20 43,072 12.46 36,837
(50, 119, 2) - - - - 7.98 27,929 6.49 22,054
(15, 31) - - - - 237.72 27,739 152.70 24,457 180.40 24,244
8 - - 220.02 13,184 134.92 9,903 164.30 9,690
aim-50-1-6no-2 - - - - 54.78 148,563
(50, 127, 2) - - - - 899.74 2,425,636 35.15 106,091
(19, 31) - - 271.66 48,118 295.76 36,233 314.72 33,226 535.52 32,712
11 218.24 27,115 237.42 16,524 251.69 13,926 450.64 13,504
aim-50-1-6no-3 - - - - - - 32.03 79,194
(50, 120, 2) - - 1125.50 3,820,213 379.20 1,127,093 3.84 13,015
(17, 27) - - 335.04 92,522 182.50 77,540 176.86 76,623 223.34 76,528
10 233.46 26,465 84.97 11,500 78.85 10,583 125.51 10,488
aim-50-1-6no-4 - - 423.19 900,024 312.10 660,848 433.63 778,334
(50, 126, 2) - - 311.94 657,833 269.36 592,225 379.00 730,513
(20, 30) - - 1102.11 94,624 587.73 44,434 721.36 38,521 1135.44 38,127
11 1040.83 72,361 531.54 23,047 667.06 17,323 1068.47 16,931
aim-50-1-6yes1-1 - - - - 619.58 1,417,018 68.76 153,541
(50, 127, 2) 80.02 213,427 50.02 140,081 25.14 78,158 26.28 68,358
(18, 29) 155.33 177,981,953 187.92 115,004 208.41 113,821 269.87 113,774 305.64 113,680
10 67.23 30,086 85.67 28,911 148.03 28,865 183.73 28,771
aim-50-1-6yes1-2 - - 74.05 183,418 75.17 198,489 30.43 75,738
(50, 126, 2) 596.16 1,757,792 38.33 106,507 61.72 175,580 20.11 57,089
(16, 34) - - 394.17 65,879 277.48 36,430 342.56 34,197 380.54 33,463
9 356.38 48,982 244.55 20,111 310.87 17,880 348.11 17,146
aim-50-1-6yes1-3 - - - - 653.68 1,027,972 525.84 846,067
(50, 128, 2) - - 150.80 397,432 61.28 146,520 42.28 100,060
(20, 27) - - 169.36 88,156 230.36 87,401 226.42 85,373 264.30 85,144
10 87.62 34,017 147.73 33,262 144.41 31,256 181.32 31,028
aim-50-1-6yes1-4 159.71 362,140 66.09 142,424 24.08 62,518 18.81 51,603
(50, 127, 2) 43.91 136,779 28.46 76,451 17.46 48,822 13.15 38,478
(19, 29) 146.56 22,063,228 55.05 24,839 100.66 24,434 132.36 23,524 280.12 23,317
9 43.19 11,842 88.56 11,435 121.40 10,525 267.98 10,318

Table 2. Results for MAX-SAT-ONE instances using static and dynamic mini-bucket heuristics.
Time limit 30 minutes. Overall best performance points are highlighted.

problem of maximizing both the number of satisfied clauses and variables assigned to
true, as described in [3].
Table 2 shows the results obtained for experiments with 8 CNF instances from the
DIMACS benchmark2 . As before, we observe that MO-AOBB+SMB(i) offers the over-
all best performance, especially for relatively large i-bounds. For example, on the aim-
50-1-6yes1-1, MO-AOBB+SMB(10) is about 25 times faster than MO-BB+SMB(10),
and about 6 times faster than MO-RDS, respectively. When using dynamic mini-bucket
heuristics, we see again that MO-AOBB+DMB(i) is competitive only for relatively
small i-bounds, due to computational overhead issues. Note also that MO-RDS could
solve only two instances, namely aim-50-1-6yes1-1 and aim-50-1-6yes1-4. The rela-
tively worse performance of MO-RDS on this domain can be explained by the quality
of its guiding heuristic function which was far inferior to the mini-bucket based ones.
Bi-objective Weighted CSPs We considered a set of standard mono-objective Weighted
CSP [17] benchmarks from the UCI Graphical Models Repository (available online at:
http://graphmod.ics.uci.edu/group/Repository). For our purpose, we converted each of
these instances into a bi-objective optimization
Pn problem by adding a secondary additive
objective function defined by F2 = i=1 g(Xi ), where g(Xi ) is a unary cost function
defined on variable Xi with costs generated uniformly at random between 0 and 10.
Table 3 shows the results obtained for experiments with 14 WCSP instances us-
ing static mini-bucket heuristics. We did not report results with dynamic mini-bucket
heuristics because of the prohibitively large computational overhead associated with
2
Available online at: ftp://dimacs.rutgers.edu/pub/challenge/satisfiability/benchmarks/cnf/
 MO-BB+SMB(i) MO-BB+SMB(i) MO-BB+SMB(i) MO-BB+SMB(i)
instance (w*, h) MO-RDS MO-AOBB+SMB(i) MO-AOBB+SMB(i) MO-AOBB+SMB(i) MO-AOBB+SMB(i)
(n, c, k) |E| i=14 i=16 i=18 i=20
time nodes time nodes time nodes time nodes time nodes
c432 (27, 45) - - - - - - - - - -
(432, 648, 2) 31 38.99 96,805 25.15 59,330 31.21 62,597 39.95 50,753
c499 (23, 55) - - 25040.22 17,482,361 27633.93 20,140,468 5275.72 5,263,053 1611.60 1,266,736
(499, 748, 2) 24 21967.54 16,840,017 24407.10 19,498,060 4290.26 4,620,932 668.43 625,078
c880 (27, 67) - - - - - - - - - -
(881, 1323, 2) 53 - - - - 9088.16 9,723,797 3181.03 3,959,806
s386 (19, 44) - - - - - - - - - -
(172, 258, 2) 13 - - - - 14.30 73,572 20.85 73,372
s1423 (24, 54) - - - - - - - - - -
(749, 1125, 2) 119 - - - - 3990.74 1,193,420 4284.95 1,195,986
s1488 (47, 67) - - - - - - - - - -
(667, 1000, 2) 10 - - - - 2510.72 11,708,708 1751.86 9,392,631
s1494 (48, 69) - - - - - - - - - -
(661, 991, 2) 14 - - - - 2794.69 17,273,392 2924.80 16,089,333
90-14-1 (22, 66) - - - - - - - - - -
(196, 392, 2) 12 19.45 130,651 7.96 23,559 13.26 17,677 24.92 16,761
90-16-1 (24, 82) - - - - - - - - - -
(256, 512, 2) 8 328.61 1,073,957 122.99 446,091 139.18 441,316 84.88 127,279
cpcs360b (20, 27) - - - - - - - - - -
(360, 720, 2) 76 85.17 119,216 113.62 119,216 181.77 119,200 524.64 119,200
blockmap-05-01 (18, 48) - - - - - - - - - -
(700, 1400, 2) 1 3.51 3,483 11.61 3,417 39.74 2,269 52.32 2,110
blockmap-05-02 (20, 53) - - - - - - - - - -
(855, 1710, 2) 2 5.72 5,579 14.52 4,296 54.78 3,484 119.87 3,463
blockmap-05-03 (22, 59) - - - - - - - - - -
(1005, 2010, 2) 2 7.59 11,325 15.78 30,324 29.03 26,454 65.96 20,459
mm-03-08-03 (20, 57) - - - - - - - - - -
(1220, 2440, 2) 1 10.50 47,783 20.06 7,669 57.27 6,426 105.90 6,257

Table 3. Results for bi-objective WCSPs derived from standard mono-objective WCSPs using
static mini-bucket heuristics. Time limit 10 hours. Overall best performance points are boxed.

relatively large i-bounds. We see that MO-AOBB+SMB(i) offers the overall best per-
formance on this domain, outperforming its competitors by several orders of magni-
tude. For example, MO-AOBB+SMB(16) solves the 90-14-1 instance in about 8 sec-
onds, whereas MO-BB+SMB(16) exceeds the 10 hour time limit. We also note that
MO-RDS was not able to solve any of the test instance within the time limit, while
MO-BB+SMB(i) could solve only one instance, namely c499.

Summary of the Empirical Evaluation Our empirical evaluation on several classes

of multi-objective optimization problems demonstrated conclusively that the AND/OR
Branch-and-Bound tree search algorithms guided by static mini-bucket heuristics were
the best performing algorithms overall. The difference between MO-AOBB+SMB(i)
and the OR tree search counterpart MO-BB+SMB(i) was more pronounced at relatively
small i-bounds (corresponding to relatively weak heuristic estimates) and amounted to
several orders of magnitude in terms of both running time and size of the search space
explored. For larger i-bounds, when the heuristic estimates are strong enough to prune
the search space substantially, the difference between MO-AOBB+SMB(i) and MO-
BB+SMB(i) decreased. We also showed that MO-AOBB+SMB(i) was able in many
cases to outperform dramatically recent state-of-the-art solvers for multi-objective opti-
mization such as MO-RDS. With dynamic mini-bucket heuristics, MO-AOBB+DMB(i)
proved competitive only for relatively small i-bounds due to computational overhead
issues. This suggests that these heuristics can be considered when space is restricted.
When comparing the AND/OR algorithms guided by mini-bucket heuristics with MO-
RDS, we observed that the former were better on relatively sparse networks while on
highly connected networks, the latter provided sometimes a better alternative.
 6 Conclusion
The paper investigates the impact of AND/OR search spaces for graphical models
on multi-objective optimization. We introduced a general multi-objective AND/OR
Branch-and-Bound algorithm and specialized it with two schemes for generating heuris-
tic estimates that can guide the search. Our empirical evaluation on several benchmarks
for MO-COP showed that the new AND/OR algorithms improved dramatically over tra-
ditional OR ones, in many cases by several orders of magnitude. Future work includes
the extension of the algorithm to explore a search graph rather than a tree, via caching,
as well as to investigate alternative control strategies such as best-first or frontier search
in the context of MO-COPs. We also plan to apply the AND/OR search principle to the
MO-RDS algorithm. Finally, we can exploit point quad-trees for the representation of
the efficient frontier in order to access the data structure more efficiently.

References
1. R. Dechter and R. Mateescu. AND/OR search spaces for graphical models. Artificial Intel-
ligence, 171(2-3):73–106, 2007.
2. R. Marinescu and R. Dechter. AND/OR branch-and-bound for graphical models. In Inter-
national Joint Conference on Artificial intelligence (IJCAI), pages 224–229, 2005.
3. E. Rollon and J. Larrosa. Bucket elimination for multi-objective optimization problems.
Journal of Heuristics, 12:307–328, 2006.
4. E. C. Freuder and M. J. Quinn. Taking advantage of stable sets of variables in constraint
satisfaction problems. In IJCAI, pages 1076–1078, 1985.
5. R. Bayardo and D. Miranker. A complexity analysis of space-bound learning algorithms for
the constraint satisfaction problem. In AAAI, pages 298–304, 1996.
6. E. Rollon and J. Larrosa. Multi-objective Russian doll search. In National Conference on
Artificial Intelligence (AAAI), pages 249–254, 2007.
7. E. Rollon and J. Larrosa. Constraint optimization techniques for multiobjective branch and
bound search. In International Conference on Logic Programming (ICLP), 2008.
8. M. Ehrgott and X. Gandibleux. Bounds and bound sets for biobjective combinatorial opti-
mization problems. Notes in Economics and Mathematical Systems, 507:241–253, 2001.
9. N. J. Nilsson. Principles of Artificial Intelligence. Tioga, Palo Alto, CA, 1980.
10. R. Dechter and I. Rish. Mini-buckets: A general scheme of approximating inference. Journal
of ACM, 50(2):107–153, 2003.
11. R. Dechter. Bucket elimination: A unifying framework for reasoning. Artificial Intelligence,
113:41–85, 1999.
12. K. Kask and R. Dechter. A general scheme for automatic generation of search heuristics
from specification dependencies. Artificial Intelligence, 129(1-2):91–131, 2001.
13. G. Verfaillie, M. Lematre, and T. Schiex. Russian doll search for solving constraint opti-
mization problems. In AAAI, pages 181–187, 1996.
14. M. Ehrgott and X. Gandibleux. Multiple criteria optimization. State of the art. Annotated
bibliographic surveys. Kluwer Academic Publishers, 2002.
15. K. Leyton-Brown, M. Pearson, and Y. Shoham. Towards a universal test suite for combina-
torial auction algorithms. In ACM Electronic Commerce, pages 66–76, 2000.
16. A. Holland. Risk Management in Combinatorial Auctions. PhD thesis, University College
Cork, 2005.
17. S. Bistarelli, U. Montanari, and F. Rossi. Semiring based constraint solving and optimization.
Journal of ACM, 44(2):309–315, 1997.

View publication stats