Page 1
Efficient Utility Functions for Ceteris Paribus Preferences
Michael McGeachie
Laboratory for Computer Science
Massachusetts Institute of Technology
Cambridge, MA 02139
mmcgeach@mit.edu
Jon Doyle
Department of Computer Science
North Carolina State University
Raleigh, NC 27695-7535
Jon Doyle@ncsu.edu
Abstract
Ceteris paribus (other things being equal) preference pro-
vides a convenient means for stating constraints on numeric
utility functions, but direct constructions of numerical utility
representations from such statements have exponential worst-
case cost. This paper describes more efficient constructions
that combine analysis of utility independence with constraint-
based search.
Introduction
Work on qualitative decision theory (Doyle & Thomason
1999) has explored methods for logical specification of ab-
stract and generic preference information as a way of over-
coming limitations suffered by direct numerical specifica-
tions of utility, especially in supporting automated adapta-
tion of utility functions to changes in preferences. Purely
logical specifications of utility functions, however, do not
support the needs of automated decision-making methods,
which must typically evaluate numerical utility functions
repeatedly in computing expected utilities of actions. Such
computations demand methods for automatically construct-
ing numeric utility functions that satisfy logical specifica-
tions.
McGeachie and Doyle (2002) use direct graph-theoretic
methods to construct several numeric utility-function repre-
sentations of sets of preference rules expressed in a language
related to the ceteris paribus preference logic of Doyle,
Shoham, and Wellman (1991). Those direct methods con-
struct a directed graph over salient model features that rep-
resents the initial preferences, and then use standard graph-
theoretic functions, such as the number of nodes reach-
able from a starting node, to define utility representations.
Such direct constructions can prove costly because small
setsofceterisparibuspreferencerulescanspecifyverylarge
graphs. In particular, one can express a lexicographic (total
linear) order using one rule per model feature.
The following describes provably correct heuristic meth-
ods that improve on these constructions by exploiting the
notion of utility independence to reduce the problem to one
of constructing and combining utility functions over smaller
Copyright c ? 2002, American Association for Artificial Intelli-
gence (www.aaai.org). All rights reserved.
sets of model features. The methods described here trans-
form ceteris paribus preference rules into constraints on
possible combinations of these subutility functions, and then
apply standard constraint-satisfaction methods to find spe-
cific combinations that yield overall utility representations
of the original ceteris paribus preferences.
Ceteris paribus preference and utility
We employ a restricted language L, patterned after (Doyle,
Shoham, & Wellman 1991) but using only the logical op-
erators ¬ and ∧, over a set of atoms F corresponding to
propositional features mentioned in preference statements.
By literals(F) we denote the atoms of F and their nega-
tions; literals(F) = F ∪{¬f | f ∈ F}. We call a complete
consistent set m of literals a model. That is, a set of features
m is a model iff m contains, for each f ∈ F, exactly one of
f and ¬f. We write M for the set of all models of L.
A model of L assigns truth values to all atoms of L, and
therefore to all formulae in L. We write f(m) for the truth
valueassignedtofeaturef bymodelm,andsaymsatisfiesa
sentence p of L, written m |= p, if the truth values m assigns
to the atoms of p make p true. We define the proposition
expressed by a sentence p, denoted [p] by [p] = {m ∈ M |
m |= p}.
A preference order is a complete preorder (reflexive and
transitive relation) ? over M. When m ? m?, we say that
m is weakly preferred to m?. If m ? m?and m??? m, we
write m ? m?and say that m is strictly preferred to m?.
If m ? m?and m?? m, then we say m is indifferent to
m?, written m ∼ m?. A utility function u : M → R maps
each model to a real number. A utility function u represents
a preference order ? just in case u(m) ≥ u(m?) whenever
m ? m?.
WedefineanewlanguageLrofpreferencerulesorprefer-
ence constraints to consist of statements of the form p ? q,
for p,q ∈ L, meaning p is desired at least as much as q,
and p ? q, meaning p is desired more than q. Models of
Lrconsist of preference orders over models of L. We define
the meaning of preference rules in terms of the notions of
L-model equivalence and modification.
The support of a sentence p ∈ L is the minimal set of
atoms determining the truth of p, denoted s(p). The support
of p is the same as the set of atoms appearing in an irre-
dundant sum-of-products sentence logically equivalent to p.
AAAI-02 279
Page 2
Two models m and m?are equivalent modulo p if they are
the same outside the support of p. Formally, m ≡ m?mod p
iff
m\(literals(s(p))) = m?\(literals(s(p)))
Model modification is defined as follows. A set of model
modifications of m making p true, written m[p], are those
models satisfying p which assign the same truth values to
atoms outside the support of p as m does. That is,
m[p] = {m?∈ [p] | m ≡ m?mod p}.
Formally, we say that a preference order ? satisfies p ? q
if and only if for all m in M, m?∈ m[p ∧ ¬q] and m??∈
m[¬p ∧ q], we have m?? m??. This means that when two
models assign the same truth values to all features not in
the support of either p or q, one making p true and q false
is weakly preferred to one making p false and q true. The
preference order satisfies a strict ceteris paribus preference
p ? q iff in addition it strictly prefers some model making p
true and q false to some model making p false and q true.
For a preference rule c, we write [c] to denote the set of
preference orders over M that satisfy c, that is, consistent
with the constraint expressed by c. We write [C] for a set of
preference rules to denote the set of orders consistent with
each c ∈ C, that is, [C] =?
preference rule c implies that m?? m??, for m?,m??∈ M,
we write m??c m??. For a set C of preference rules, we
write m??Cm??to mean that m??cm??for each c ∈ C.
We define the support of C, denoted F(C), to be the set
of features in L present in the support of statements of L ap-
pearing in constraints in C. Formally, F(C) contains those
features f such that either f or ¬f appears in?
a finite set C of ceteris paribus preference rules, a utility
function u that represents some order in [C] in an efficient
manner.
c∈C[c]. Consistent rules and
rule sets admit at least one consistent preference order. If a
c∈Cs(c).
The following examines the problem of constructing, for
Intermediate representation
The utility construction methods developed here employ
an intermediate representation in terms of rules that relate
paired patterns of specified and “don’t care” feature values.
Let C be a finite set of preference rules. Because each
preference rule mentions only finitely many features, F(C)
is also finite, and we write N to mean |F(C)|.
We construct utility functions representing the constraints
inC intermsofmodel features. Features not specified inany
rule in C are not relevant to compute the utility of a model,
since there is no preference information about them in the
set C. Accordingly, we focus our attention on F(C).
We define the intermediate representation relative to an
enumeration V = (f1,...,fN) of F(C).
We define the language Lr(V) of intermediate rules in
terms of a language L(V) of intermediate propositions over
the ternary alphabet Γ = {0,1,∗}.
A statement in L(V) consists of a sequence of N letters
drawn fromthe alphabet Γ, so that L(V) consists of words of
length N over Γ. For example, if V = (f1,f2,f3), we have
∗10 ∈ L(V). Given a statement p ∈ L(V) and a feature
f ∈ F(C), we write f(p) for the value in Γ assigned to f in
p. In particular, if f = Vi, then f(p) = pi.
An intermediate rule in Lr(V) consists of a triple p ? q in
which p,q ∈ L(V) have matching ∗ values. That is, p ? q
is in Lr(V) just in case pi = ∗ if and only if qi = ∗ for
all 1 ≤ i ≤ N. For example, if V = (f1,f2,f3), Lr(V)
contains the expression ∗10 ? ∗00 but not the expression
∗10 ? 0∗0. We refer to the statement in L(V) left of the
? symbol in a rule r as the left-hand side of r, and denote
it LHS(r). We define right-hand side RHS(r) analogously.
Thus p = LHS(p ? q) and q = RHS(p ? q).
We regard statements of L(V) containing no ∗ letters as
models of L(V), and write M(V) to denote the set of all
such models. We say a model m satisfies s, written m |= s,
just in case m assigns the same truth value to each feature
as s does for each non ∗ feature in s. That is, m |= s iff
f(m) = f(s) for each f ∈ F(C) such that f(s) ?= ∗. For
example, 0011 satisfies both ∗0∗1 and 00∗∗.
We project models in M to models in M(V) by a map-
ping α : M → M(V) defined, for each m ∈ M and
f ∈ F(C),sothatf(α(m)) = 1iff ∈ mandf(α(m)) = 0
if ¬f ∈ m. This projection induces an equivalence rela-
tion on M, and we write [m] to mean the set of models
in M mapped to the same model in M(V) as m, namely
[m] = {m?∈ M | α(m?) = α(m)}.
We say that a pair of models (m,m?) of L(V) satisfies
a rule r in Lr(V), and write (m,m?) |= r, if m satisfies
LHS(r), m?satisfies RHS(r), and m,m?have the same
value for those features represented by ∗ in r, that is, mi=
m?
ple, (100,010) |= 10∗ ? 01∗, but (101,010) ?|= 10∗ ? 01∗.
The meaning [r] of a rule r in Lr(V) is the set of all pref-
erence orders ? over M such that for each m,m?∈ M,
if (α(m),α(m?)) |= r, then m ? m?. Thus a rule ∗∗01 ?
∗∗10 represents the four specific preferences
0001 ? 0010
1001 ? 1010
Note that this says nothing at all about the preference rela-
tionship between, e.g., 0101 and 1010.
Constructing subutility functions over subsets of features
requires the ability to consider models restricted to these
subsets. We write M[S] to denote the set of models over
a feature set S ⊆ F, so that M = M[F]. If m ∈ M[S] and
S?⊆ S , we write m ? S?to denote the restriction of m to
S?, that is, the model m?∈ M[S?] assigning the same values
as m to all features in S?. We say that a model m ∈ M[S]
satisfies a model m?∈ M[S?], written m |= m?just in case
S?⊆ S and m?= m ? S?.
The support features of a statement p in L(V), written
s(p), are exactly those features in p that are assigned value
either 0 or 1, which represent the least set of features needed
to determine if a model of L(V) satisfies p. The support fea-
tures of a rule r in Lr(V), denoted s(r), are the features in
s(LHS(r)). The definition of Lr(V) implies that s(LHS(r))
= s(RHS(r)).
One can show (McGeachie 2002) that, given a set C of
ceteris paribus rules we can convert them into a set C∗of
intermediate representation rules equivalent in the sense that
ifor each 1 ≤ i ≤ N such that LHS(r)i= ∗. For exam-
0101 ? 0110
1101 ? 1110
280 AAAI-02
Page 3
both sets denote the same set of preference orders [C] =
[C∗]. Thus, we can use the language L(V) in the following
and know that our conclusions hold over statements in L.
A basic utility function
We now define one utility function, u : M(V) → R con-
sistent with a set C∗of rules in the intermediate representa-
tion Lr(V). Composition of this function with the projection
α : M → M(V) yields a utility function on M.
To construct this utility function, we first use the rules in
C∗to define a directed graph G(C∗) over M(V), called a
model graph, that represents the preferences expressed in
C∗. Each node in the graph represents one of the 2Npos-
sible models M(V). The model graph G(C∗) contains an
edge e(m1,m2) from source m1to sink m2if and only if
(m1,m2) |= r for some rule r ∈ C∗. Each edge represents
a preference for the source over the sink. If C∗is consistent,
then G(C∗) is acyclic; a cycle would indicate the inconsis-
tency of C∗. We can determine whether m is preferred to m?
by looking for a path from m to m?in G(C∗). The existence
of such a path means m ? m?.
The utility function used here assigns to a model m ∈
M(V) a value u(m) equal to the number of nodes on the
longest path originating from m in G(C∗). We call this the
minimizing utility function and elsewhere show it consistent
with the preferences expressed in C∗(McGeachie & Doyle
2002).
Utility independence
Utility independence (UI) exists when the contribution to
utility of some features is independent of the values of other
features. In the following subsections, we demonstrate how
this expedites our calculation of utility from preferences in
the intermediate representation.
The general definition for utility independence of features
Siof features Sjis
[(m2? Si) ∪ (m1? Sj) ? (m3? Si) ∪ (m1? Sj)] ⇒
[(m2? Si) ∪ (m4? Sj) ? (m3? Si) ∪ (m4? Sj)]
for all m1,m2,m3,m4(Keeney & Raiffa 1976). The idea is
that values m2for Siare preferred to values m3for Si, no
matter what values Sjhappens to assume. We are interested
in computing a partition S = {S1,S2,...,SQ} of F(C) such
that each set Siis utility independent of its complement,
F(C)\Si. That is, the feature sets Siare all mutually util-
ity independent (MUI). A basic decision theory result shows
thatasetofMUIfeatureshasanadditivedecompositionutil-
ity function of the form
(1)
u(m) =
k
?
i=1
tiui(m),
(2)
for subutility functions ui : M(V) → R assigning utility
values to models based on the restriction of the models to
Si. Having a large number of utility independent feature sets
of small cardinality therefore greatly simplifies the compu-
tation of a utility function.
Common methods for determining utility independence
assume independence relations are given a priori or elicited
directly from a human decision maker (Keeney & Raiffa
1976; Bacchus & Grove 1996). To employ this concept in
automatically computing utility functions, we use a differ-
ent approach. We first assume that each feature is utility in-
dependent of all other features, and then try to discover for
which features this assumption is invalid by reference to the
preferences in C∗. For each f ∈ F(C), we assume that f
is UI of F(C)\{f}. We then look for evidence that demon-
strates two feature sets are not UI of each other.
The intuitive idea is to find a pair of rules that demonstrate
that preference for some features depends on the value of
other features. To use a very simple example, suppose V =
(f1,f2,f3), and consider two rules in Lr(V); the rules 01∗ ?
11∗ and 10∗ ? 00∗. It is easy to see that the preference
expressed over f1switches depending on the value of f2.
I.e., {f1} is not UI of {f2}.
Sets Si,Sj are utility dependent if we can demonstrate
models m1, m2, m3, and m4for some feature sets and a
pair of rules r1,r2such that the condition (1) does not hold.
The correspondence is analogous to condition (1): we want
all of the following
(m2? Si) ∪ (m1? Sj) |= LHS(r1),
(m3? Si) ∪ (m1? Sj) |= RHS(r1),
(m2? Si) ∪ (m4? Sj) |= RHS(r2),
(m3? Si) ∪ (m4? Sj) |= LHS(r2).
A method for finding such r1,r2,Si,Sjis as follows. Since
Sjmust be a subset of the support features of r1, and m1re-
stricted to Sjmust satisfy both LHS(r1) restricted to Sjand
RHS(r1) restricted to Sj, we can look for rules of this form.
Lexically, these rules are easy to recognize: some of the fea-
tures specified in the rule have the same value on the left-
and right-hand sides of the rule. Then we look for another
rule, r2, with the same property: there is a set of features
S?
an m4satisfies both LHS(r2) restricted to S?
restricted to S?
be a subset of Sj. Again, we are looking for a rule that spec-
ifies the same values for the same features on the left- and
right-hand sides, but these features must be a subset of those
features we found for r1. If the previous conditions hold, we
have fixed m1,m4, and Sjused in conditions (1) and (3).
We then check that r1,r2are such that an Sican be found
that is disjoint with Sjand a subset of the support features
of both r1and r2, and an m2can be found that satisfies both
LHS(r1) restricted to Siand RHS(r2) restricted to Si. Here
we are looking for a preference over models restricted to Si
that switches with the values assigned to Sj. Again, this is
easy to check for, by doing lexical comparisons on the left-
and right-hand sides of the support feature sets of rules. If
all the preceding holds for some Si,Sj, then Siis utility
dependent on Sj. We are assured of this since the condition
(1) is violated.
We require a partition S = {S1,S2,...,SQ} of F(C),
into MUI feature sets. A partition can be computed by start-
ing with a set S of singleton sets; S1= {f1}, S2= {f2},
..., SN = {fN}. We consider each pair of rules (r1,r2) in
(3)
jthat is a subset of the support features of r2and there is
jand RHS(r2)
j, with the additional restriction that S?
jmust
AAAI-02 281
Page 4
C∗, and check if a preference for one feature changes with
the value assigned to another feature by using the preceding
method. If so, we have discovered sets of utility dependent
features, and we update our partition S by joining these two
sets together.
After performing such overlap calculations, we have com-
puted a partition of F(C) into MUI subsets. This method
clearly produces a partition by starting with one, by combin-
ing utility-dependent subsets, and by stopping when no two
subsets exhibit utility dependence on each other, making the
partition elements MUI.
Utility computation
We now describe how to compute one utility function con-
sistent with the set C∗of transformed input ceteris paribus
preferences expressed in Lr(V). Using the methods of the
previous section, we find a partition of F(C) into MUI fea-
ture sets S1,S2,...,SQand seek an additive utility func-
tion of the form given in Equation (2) consisting of a linear
combination of subutilities, with each subutility function a
separate function of a particular Si.
We have two tasks: to craft the subutility functions uiand
to choose the scaling constants ti. We accomplish these two
tasks in roughly the following way. We construct subutility
functions by restricting rules to a set Si. This is essentially
a projection of a rule onto a particular set of features, in the
same manner as we have defined restriction of models to
a set of features. We then apply the graph-theoretic utility
function definition to these restricting rules to obtain subu-
tility functions ui. However, rules that do not conflict in gen-
eral can conflict when restricted to different feature sets. We
use a boolean constraint satisfaction solver to resolve these
conflicts. To assign values to scaling parameters ti, we de-
fine linear inequalities that constrain the variables tiand use
standard linear programming methods to solve the inequali-
ties for suitable scaling values ti.
Subutility functions
We first define subutility functions ui(m) that take as input
the values for the features Si, and return an integer.
We examine the structure of the rules in the intermediate
representation. Since we are only concerned with the fea-
tures Si, we can ignore rules that do not have members of Si
in their support feature set. We construct a restricted model
graph, Gi(C∗), where we consider each model m ∈ M[Si]
tobeanodeinthegraph.Eachruler andpair(m1,m2)|= r,
with m1,m2∈ M[Si], indicate a directed edge from m1to
m2in Gi(C∗). Note that if a rule r ∈ C∗has Si\s(r) ?= ∅,
then the rule makes more than one edge in the model graph
Gi(C∗). Specifically, a rule r makes
2|Si|−|Si∩s(r)|
edges. The construction of this graph Gi(C∗) exactly par-
allels the construction of the general model graph G, as de-
scribed earlier. We then use the minimizing utility function
for ui, wherein each node has utility equal to the length of
the longest path originating at the node.
Conflicting rules
erences C∗have no conflicting rules, it is possible that a re-
stricted model graph Gi(C∗) has cycles in it even though a
model graph G(C∗) for F(C) does not. Since our definition
of graph theoretic utility functions does not handle cycles,
we must fix this difficulty before we can use such a function
for a subutility function.
Let Ri represent the set of rules r ∈ C∗such that
s(r) ∩ Si?= ∅. Rules in a set Riconflict if they imply a cy-
cle in any model graph Gi(C∗) of some utility independent
set of features Si. Consider now a minimal set of conflict-
ing rules Ri, where for each r in Ri, r models Lr(V), so
that for any r ∈ Ri, Ri\{r} implies no cycles or implies a
different cycle in the model graph Gi(C∗) of Si. Since we
assume the input preferences are not contradictory, a set of
rules can only conflict when the rules are restricted to a par-
ticular subset of their support features. The restriction of a
rule to a set of features S is another rule in the intermediate
representation, but over fewer features:
Although we assume that the input pref-
r ? S = RHS(r) ? S ? LHS(r) ? S
Consider rules x,y in Lr(V), with V = (f1,f2,f3,f4), and
x = ∗01∗ ? ∗10∗, y = ∗∗01 ? ∗∗10. If we examine the
restriction to feature three: x ? {f3} and y ? {f3} , then we
have x ? {f3} = 1 ? 0 and y ? {f3} = 0 ? 1. Thus,
when restricted to f3it is inconsistent to assert both x and
y. In these cases, we say that x,y conflict on f3. If we let
S = {f3}, then we say x,y conflict on the set S.
Let ra,rb,rc ∈ Ri. Suppose ra,rb, and rcconflict on
Si. E.g. we might have ra ? Si = 001 ? 100,rb ? Si =
100 ? 010,rc? Si= 010 ? 001. We resolve conflicts by
choosing one of the conflicting rules and removing the rule,
temporarily, from the set Ri. The following section explains
how to choose which rule to remove.
Suppose there are sets of conflicting rules Y1,Y2,...,YK,
where each is composed of rules r ∈ Ri. By definition, each
set Ykrepresents a cycle in Gi(C∗). We require that all dis-
tinct cycles in Gi(C∗) are represented by (perhaps dupli-
cate) conflicting rule sets Yk. Since Ykis a minimal set im-
plying a particular cycle in Gi(C∗), for any r ∈ Ykwe know
Yk\{r} does not imply the same cycle in Gi(C∗). All cycles
in Gi(C∗) are represented by some Yk∈ {Y1,Y2,...,YK}.
We will choose a rule r ∈ Ykfor each set Yk, and remove
r from Ri (discussed below). Since we stipulate that all
r?∈ Ykare taken from the set Ri, when we remove r from
Rithis also removes r from all sets Ykwhich might contain
r.Afterremovalofr,werebuildGi(C∗)withtheremainsof
Ri. We now have a model graph Gi(C∗) that is cycle-free.
Note that, after this removal process, |Ri| ≥ 1, since one
rule cannot imply a cycle. With no cycles, we can define ui
to be the subutility function for Sibased on the minimizing
utility function of Gi(C∗). We say that the resulting func-
tion uiagrees with rules r ∈ Ri, and that uidisagrees with
those rules r that were removed from Ri. When uiagrees
with r, then for all (m1,m2) |= r, ui(m1) > ui(m2).
Ifautilityfunctionuisconsistentwithasetofpreferences
C∗, then u represents some order in [C∗]. This is equiva-
lent to having u(m1) > u(m2) whenever m1 ?C∗ m2.
This translates into the following property of the subutility
282 AAAI-02
Page 5
functions uirelating utility contributions due to the subutil-
ity functions agreeing and disagreeing with an intermediate
rule. To state the result, we define Sa(r) and Sd(r) to be the
sets of indices of subutility functions respectively agreeing
and disagreeing with r.
Theorem 1 A utility function u is consistent with a rule r if
for all (m1,m2) |= r, we have
?
i∈Sa(r)
ti(ui(m1)−ui(m2)) >
?
j∈Sd(r)
tj(uj(m2)−uj(m1))
(4)
We omit the proof.
This theorem has the following important consequence.
Corollary 1 In a utility function u of the form (2) over a
partition of F(C) consistent with C∗, each rule r ∈ C∗
must agree with some subutility function ui.
Otherwise we have |Sa(r)| = 0 and |Sd(r)| ≥ 1, and Equa-
tion (4) will not be satisfied.
Choosing scaling parameters
Once we have a collection of utility independent sets Si, we
create subutility functions as described above. We can then
choose scaling parameters tibased on which rules disagree
with each subutility function ui. There are several possible
strategies for choosing these parameters. Due to space con-
straints, we mention briefly the simplest case, then present
the most general method.
If no subutility functions disagree with any rules, we have
the following case. For any rule r and all i such that r ∈ Ri,
uiagrees with r. We have: ui(m1) > ui(m2) for each ui,
and each pair (m1,m2) |= r. Then we are unconstrained in
our choices of ti, since tiui(m1) > tiui(m2) holds for any
ti> 0.
Constraint satisfaction
If we have several UI sets Siwith
conflicts between rules, then we must use a more compli-
cated strategy for assigning scaling parameters ti, in which
case we construct and solve a constraint satisfaction prob-
lem from the set of conflicts. Constraint solvers exist that
can quickly handle problems with tens of thousands of terms
(Selman, Levesque, & Mitchell 1992). Although this may be
costly, thispriceispaid onlywhen the utilityfunction iscon-
structed. The evaluation of the utility function on models of
L(V) is independent of the construction cost.
Corollary 1 states that each rule r must agree with some
subutility function ui. For each utility independent feature
set Si, let Yi1,Yi2,...,YiKbe sets of conflicting rules, where
each is composed of rules r ∈ Ri. Each set Yikrepresents
a cycle in Gi(C∗); and let Y be the set of all such conflicts.
Let Rc = ∪i,kYikbe the set of all rules involved in any
conflict.
Our satisfiability problem uses a conjunction of disjunc-
tions (conjunctive normal form) of propositional variables
zij, with zijinterpreted as stating that subutility function ui
agrees with rule rj ∈ Rc. Let Xj = {l | Sl∩ s(rj) ?= ∅}
denote the set of indices of UI sets that overlap with rj.
Conjuncts in the formula are of one of two forms: those
representing the subutility functions indicated by Xj; and
those representing conflicts between rules of a particular cy-
cle Yik. Those of the first category are of form ∨i∈Xjzij.
This represents the possible subutility functions a rule might
agree with, accordingly in a solution to the formula, one of
these variables must be true.
The other conjuncts represent a particular cycle on a par-
ticular UI set. If Yikis a conflict set on Si, then the conjunct
is of the form ∨j:rj∈Yik¬zij. That is, uimust disagree with
at least one of the rules in Yik. Combining conjunctions of
both types, we can write the entire satisfiability formula as
j=1
i∈Xj
Consider an example. Suppose we have sets S1,S2with
rule conflicts. Further suppose that r1,r2∈ R1,R2, and that
s(r1) = s(r2) = S1∪ S2. Suppose that Y11= {r1,r2} and
Y21= {r1,r2}, that is, r1,r2conflict on both of S1,S2. We
make a satisfiability formula as so:
Q
?
?
zij
?
?
Yik∈Y
?
j:rj∈Yik
¬zij
(z11∨ z21) ∧ (z12∨ z22) ∧ (¬z11∨ ¬z12) ∧ (¬z22∨ ¬z21)
Once we have this formula, we use a solver to arrive at
a solution. It can be shown that the satisfiability problem is
always satisfiable if the preferences C∗admit an additive
decomposition utility function (McGeachie 2002). A solu-
tion to the satisfiability problem can be translated back into
a construction for the subutility functions using the transla-
tion defined above, we simply look at which subutility func-
tions disagree with which rules. We then remove those rules
from the relevant sets Ri, then construct uiaccording to Ri,
which is now conflict-free.
Linear inequalities
rules disagree with which subutility functions. However, we
must then set the scaling parameters, ti, so as to satisfy
Equation (4). We can do so by building a list of constraints
on the values that the scaling parameters may assume.
Suppose subutility functions for the utility-independent
sets Sd(r) disagreed with r, while subutility functions for
the utility-independent sets Sa(r) agreed with r. Then we
add an inequality of the form
?
to a list I of inequalities for each pair (m1,m2) |= r. The
inequalities I constrain the total utility function to assign
higher utility to m1than to m2. Note that the inequality need
notcontaintermsforujforj notinSd(r)orSa(r),since,by
definition of (m1,m2) |= r, we have m1? Sj= m2? Sj.
The total number of linear inequalities is far less than 2F(C).
Specifically, each rule r contributes
?
inequalities to the set I of inequalities. One obtains (5) by
noticing the number of inequalities contributed by a rule is
the number of different values of ui(m1) - ui(m2) for i ∈
(Sd(r) ∪ Sa(r)) and (m1,m2) |= r.
The satisfiability solver tells us which
i∈Sa(r)∪Sd(r)
tiui(m1) >
?
i∈Sa(r)∪Sd(r)
tiui(m2)
Si:s(r)∩Si?=∅
2|Si\s(r)|
(5)
AAAI-02 283
Page 6
We solve the system of linear inequalities I using any lin-
ear inequality solver. We note that it is possible to phrase this
as a linear programming problem, and use any of a number
of popular linear programming techniques to find scaling pa-
rameters ti. For example, see (Chv´ atal 1983).
It can be shown that if the system of linear inequalities,
I, has a solution, this solution corresponds to a utility func-
tion u consistent with C∗. If the inequalities prove unsatisfi-
able, it may be because the preferences do not admit a linear
scaling between subutility functions. We can either follow
(McGeachie & Doyle 2002) and use the minimizing util-
ity function over the degenerate partition S = {F(C)} or,
less drastically, join partition elements together to perform
constraint satisfaction and linear programming on a smaller
problem (a solution used in (Boutilier, Bacchus, & Braf-
man 2001) to solve the same problem). Work in progress
addresses optimal choice of which feature sets to join to-
gether.
Conclusions
We have summarized a method for constructing numeric
utility-function representations of preferences specified us-
ing the ceteris paribus preference logic of (Doyle, Shoham,
& Wellman 1991). We sketch the complexity of our meth-
ods, then compare to similar ceteris paribus reasoning sys-
tems.
There are two different efficiency questions to ask. One is
the time and space required to construct u, the other is the
time and space required to evaluate u on a particular model
m. Constructing u involves first computing the utility in-
dependent partition of features, which takes time O(|C∗|2).
Then we solve a satisfiability problem, where time required
depends on the number of rules involved in conflicts on each
UI set. In pathological cases, the number of conflicts could
be as high as |C∗|!, if every rule conflicts with every other
set of rules. Finally we solve a system of linear inequalities,
where the number of inequalities is
?
Computing u(m) involves computing ui(m), where uiis a
minimizing utility function, for all the UI feature sets. Each
of the subutility functions can be exponential in the size of
the UI set, |Si|; in the worst case, this means exponential in
|F(C)|.
Since we assume our input preferences |C| are not inher-
ently contradictory, we anticipate in practice there will be
manageable numbers of conflicting rules. If in addition, each
set Siis of size logN, our algorithm requires polynomial
time and space. There are less than |C∗| ∗?Q
Each model graph Gi(C∗) has at most 2log Nnodes, so eval-
uating u(m) takes time O(k ∗ N).
Other researchers have proposed methods of computing
with different representations of ceteris paribus preferences.
The work of (Bacchus & Grove 1995) and (Mura & Shoham
1999) use quantified preference statements, in contrast to
our qualitative preference statements. Our work is similar to
r∈C∗
?
Si:s(r)∩Si?=∅
2|Si\s(r)|
i=12log Nlin-
ear inequalities, so construction of u takes polynomial time.
the work of Boutilier, Bacchus, Brafman (2001), who com-
pute an additive decomposition utility function from quanti-
fied preferences. Their method uses subutility functions that
are exponential-size lookup tables, which is similar to our
exponential-size graph theoretic subutility functions. Ear-
lier work by (Boutilier et al. 1999) uses qualitative condi-
tional ceteris paribus preferences, and presents some strong
heuristics for computing dominance queries, but uses a very
different representation for ceteris paribus preferences.
Acknowledgements
This work was supported in part by DARPA under contract
F30602-99-1-0509. Michael McGeachie is supported in part
by a training grant from the National Library of Medicine,
and a grant from the Pfizer corporation.
References
Bacchus, F., and Grove, A. 1995. Graphical models for prefer-
ence and utility. In Proceedings of the Eleventh Conference on
Uncertainty in Artificial Intelligence, 3–19. Morgan Kaufmann.
Bacchus, F., and Grove, A. 1996. Utility independence in a qual-
itative decision theory. In Proceedings of the Fifth International
Conference on Knowledge Representation and Reasoning, 542–
552. Morgan Kaufmann.
Boutilier, C.; Bacchus, F.; and Brafman, R. L.
networks: A directed graphical representation of conditional util-
ities. In Proceedings of Seventeenth Conference on Uncertainty
in Artificial Intelligence. To Appear.
Boutilier, C.; Brafman, R. I.; Hoos, H. H.; and Poole, D. 1999.
Reasoning with conditional ceteris paribus preference statements.
In Proceedings of Uncertainty in Artificial Intelligence 1999
(UAI-99).
Chv´ atal, V. 1983. Linear Programming. New York: W.H. Free-
man and Company.
Doyle, J., and Thomason, R. H. 1999. Background to qualitative
decision theory. AI Magazine 20(2):55–68.
Doyle, J.; Shoham, Y.; and Wellman, M. P. 1991. A logic of
relative desire (preliminary report). In Ras, Z., ed., Proceedings
of the Sixth International Symposium on Methodologies for In-
telligent Systems, Lecture Notes in Computer Science. Berlin:
Springer-Verlag.
Keeney, R., and Raiffa, H. 1976. Decisions with Multiple Ob-
jectives: Preferences and Value Tradeoffs. New York: Wiley and
Sons.
McGeachie, M., and Doyle, J. 2002. Utility functions for ceteris
paribus preferences. Submitted for publication.
McGeachie, M. 2002. Utility functions for ceteris paribus pref-
erences. Master’s thesis, Massachusetts Institute of Technology,
Cambridge, Massachusetts. In preparation.
Mura, P. L., and Shoham, Y. 1999. Expected utility networks. In
Proc. of 15th conference on Uncertainty in Artificial Intelligence,
366–373.
Selman, B.; Levesque, H. J.; and Mitchell, D. 1992. A new
method for solving hard satisfiability problems. In Rosenbloom,
P., and Szolovits, P., eds., Proceedings of the Tenth National Con-
ference on Artificial Intelligence, 440–446. Menlo Park, Califor-
nia: AAAI Press.
2001. Ucp-
284 AAAI-02
Download full-text