# Utility Functions for Ceteris Paribus Preferences

**ABSTRACT** Ceteris paribus (all-else equal) preference statements concisely represent preferences over outcomes or goals in a way natural to human thinking. Although deduction in a logic of such statements can compare the desirability of specific conditions or goals, many decision-making methods require numerical measures of degrees of desirability. To permit ceteris paribus specifications of preferences while providing quantitative comparisons, we present an algorithm that compiles a set of qualitative ceteris paribus preferences into an ordinal utility function. Our algorithm is complete for a finite universe of binary features. Constructing the utility function can, in the worst case, take time exponential in the number of features, but common independence conditions reduce the computational burden. We present heuristics using utility independence and constraint-based search to obtain efficient utility functions.

**0**Bookmarks

**·**

**74**Views

- [Show abstract] [Hide abstract]

**ABSTRACT:**Operations research (OR) and artificial intelligence (AI) disciplines have been playing major roles on the design of new intelligent systems. Recently, different contributions from both fields have been made on the models design for problems with multi-criteria. The credit scoring problem is an example of that. In this problem, one evaluates how unlikely a client will default with his payments. Client profiles are evaluated, being their results expressed in terms of an ordinal score scale (Excellent ≻ Good ≻ Fair ≻ Poor). Intelligent systems have then to take in consideration different criteria such as payment history, mortgages, wages among others in order to commit their outcome. To achieve this goal, researchers have been delving models capable to render these multiple criteria encompassed on ordinal data. The literature presents a myriad of different methods either on OR or AI fields for the multi-criteria models. However, a description of ordinal data methods on these two major disciplines and their relations has not been thoroughly conducted yet. It is key for further research to identify the developments made and the present state of the existing methods. It is also important to ascertain current achievements and what the requirements are to attain intelligent systems capable to capture relationships from data. In this chapter one will describe techniques presented for over more than five decades on OR and AI disciplines applied to multi-criteria ordinal problems.11/2014; - [Show abstract] [Hide abstract]

**ABSTRACT:**Many users of libraries or subscribers of news services have sufferedthe well-known troublesome problem of getting 'properly' notified about latestpublications or events. Definitively this should happen in a personalized manneras much as possible. The acquisition and maintenance of sophisticated userpreferences about topics of interest as well as knowledge about a user's personalsituation are prerequisites for better solutions than current ad hoc approaches. - SourceAvailable from: Darius Braziunas

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