Strategies Query for Priced Information
(Extended Abstract)
Moses Charikar
Ronald Fagin
Venkatesan Guruswami Amit Sahai
Jon Kleinberg
Prabhakar Raghavan
We consider a class of problems in which an algorithm seeks to compute a function over a set of inputs, where each input has an associated price. The algorithm queries inputs sequentially, trying to learn the value of the function for the minimum cost. We apply the competitive analysis of algorithms to this framework, designing algorithms that incur large cost only when the cost of the cheapest proof for the value of is also large. We provide algorithms that achieve the optimal competitive ratio for functions that include arbitrary Boolean AND/OR trees, and for the problem of searching in a sorted array. We also investigate a model for pricing in this framework, constructing a set of prices for any AND/OR tree that satises a very strong type of equilibrium property.
decisions. How should one query data in the presence of a given price structure? Previous theoretical analysis has posited settings in which there is a target piece of information, and the goal is to locate it as rapidly as possible; see for example the work of Etzioni et al. [5] and Koutsoupias et al. [9]. Here we take an alternate perspective, motivated by the following type of consideration. Suppose we have derived, through some pre-processing based on data mining or other statistical means, a decision rule that we wish to apply. To take a toy example, such a rule might look like If Analyst A values Microsoft at $X or Analyst B values Netscape at $Y; and if Analyst C values Oracle at $Z or Analyst D values IBM at $W; then we should sell our shares of eBay. The decision rule in this example depends on four available information sources, which we could label , , , and ; each has a Boolean value. It is possible to evaluate the rule, under some circumstances, without querying all the information sources. If each of these pieces of information has an associated price, what is the best strategy for evaluating the decision rule? Note the following features of this toy example. There is an underlying set of information sources, but our goal is not simply to gather all the information; rather it is to collect (as cheaply as possible) a subset of the information sufcient to compute a desired function . Thus, a crucial component of our approach is the view that disparate information sources contain raw data to be combined to reach a decision, and it is the structure of this combination that determines the optimal strategy for querying the sources. Our setting may be further generalized to allow inputs that are entire databases, rather than bits (say, a demographic information database from a vendor such as Lexis-Nexis), and the goal is to distill valuable information from a combination of such databases; this generalization suggests an interesting direction for further work. An Illustrative Example. In Figure 1 we depict the above toy example, with the decision rule represented by a tree-structured attached to the inBoolean circuit, and with the prices puts. An algorithm is presented with this circuit and the vector of prices; the hidden information is the setting of the four Boolean variables. It must query the variables, one by one, until it learns the value of the circuit; with each variable it queries, it pays the associated cost. We could ask for an algorithm that incurs the minimum worst-case cost over all settings of the variables; but this is too simplistic: many of the natural functions we wish to study (including all Boolean AND/OR trees) are evasive [3], so any algorithm can be made to pay for all the variables, and all algorithms perform equally poorly under this measure.
) 8 6 5 2 4 2 3 2 10 ( ' & 7
The potential of priced information sources [12, 13] that charge for usage is being discussed in a number of domains software, research papers, legal information, proprietary corporate and nancial information and it forms a basic component of the larger area of electronic commerce [4, 6, 16, 17]. In a networked economy, we envision software agents that autonomously purchase information from various sources, and use the information to support
Computer Science Department, Stanford University, CA 94305. Email: [e-mail]. Research supported by the Pierre and Christine Lamond Fellowship, NSF Grant IIS-9811904 and NSF Award CCR-9357849, with matching funds from IBM, Mitsubishi, Schlumberger Foundation, Shell Foundation, and Xerox Corporation. Most of this work was done while the author was visiting IBM Almaden Research Center. IBM Almaden Reseach Center, 650 Harry Road, San Jose, CA 95120. Email: fagin,pragh @almaden.ibm.com. Laboratory for Computer Science, MIT, Cambridge, MA 02139. Email: venkat,amits @theory.lcs.mit.edu. Research supported by an IBM Graduate Fellowship and DOD Fellowship, respectively. Most of this work was done while the authors were visiting IBM Almaden Research Center. Department of Computer Science, Cornell University, Ithaca NY 14853. Email: [e-mail]. Supported in part by a David and Lucile Packard Foundation Fellowship, an Alfred P. Sloan Research Fellowship, an ONR Young Investigator Award, and NSF Faculty Early Career Development Award CCR-9701399.
# # " " % ! $
A
cost:
B
3
C
1
D
4
6
Figure 1: A Boolean function with priced inputs
internal nodes. One can easily build examples in which an optimal algorithm cannot follow a depth-rst search style evaluation of variables and subtrees. Indeed, the criteria for optimality lead quickly to issues similar to those in the search ratio problem and minimum latency problem for weighted trees [1, 9] problems for which polynomial-time algorithms are not known. It is not at all obvious that the optimal evaluation algorithm for a Boolean tree can be found efciently, or even have a succinct description, even in the case of complete binary trees. We also consider functions that generalize Boolean trees, including MIN/MAX game trees. Finally, we investigate analogues of searching, sorting, and selection within our model; here too, problems that are well-understood in traditional settings become highly non-trivial when prices are introduced.
B A @
for any algorithm, then, is
)
' H&
)
C
' H&
R
)
H
R
R
The model above is general enough to include almost any problem in which an algorithm adaptively queries its input. Our approach will be to focus on simple functions that have been wellstudied in the case of unit prices. We nd that the inclusion of arbitrary prices on the inputs gives the problem a much more complex character, and leads to query algorithms that are novel and non-obvious. Our primary focus will be on Boolean AND/OR trees (briey, Boolean trees) these are tree circuits rooted (w.l.o.g.) at an AND gate, with each leaf corresponding to a distinct variable, and with each root-to-leaf path strictly alternating AND and OR gates at the
' H&
H
R
)
The best possible competitive ratio
This denition naturally suggests the following questions: How does the above competitive ratio depend on the topology of the underlying tree? Can we characterize the structure of the cost vector that achieves ? We prove a general characterization theorem for ; as a corollary, we nd that the uniform cost vector is in fact extremal for the complete binary tree. We say that a Boolean tree on inputs can simulate an AND gate of size if by xing the values of some inputs, the function induced on the remaining inputs is equivalent to a simple AND of variables. (We dene the simuis equal to the lation of an OR gate analogously.) We show: maximum for which can simulate an AND gate or an OR gate is always an integer). The proof of size (this also shows that is obtained using information from the lower bound estimates that form a component of our optimal balance-based algorithm. These results are described in Section 2. We give extensions of some of these results to more general types of functions. All of these functions are dened over a tree structure, and for each we can give an efcient algorithm whose competitive ratio is within a factor of of optimal.
R ' H& ) ' H& 0 ) 'RS
DC
(1)
H
' H& 0
)
0 Q P I 3 ' H& 21
)
G G
FE C
4
FC
&
"
The competitive analysis of algorithms [2] ts naturally within our framework; we dene the performance of an algorithm on a given setting of the variables to be the ratio of the cost incurred by to the cost of the cheapest proof for the value of the function. The competitive ratio of is then the maximum of this performance ratio over all settings of the variables. In the example above, consider the algorithm that rst queries . If is , it then queries and (if necessary); if is , it then queries , then and (if necessary). The perforwhen the setting is mance ratio of is : queries all the variables and pays , while querying only and would prove the value of the function is . Inachieves the optideed, this is the competitive ratio of , and mal competitive ratio of any algorithm on this function, with this cost vector. Two aspects of are noteworthy: (i) it is adaptive its behavior depends on the values of the inputs it has read, and (ii) it does not always read the inputs in increasing order of price. A Framework. We now describe a general framework that captures the issues and example discussed above. We have a function over a set of variables. Each variable has a non-negative cost ; the vector will be called the cost vector. A setting of the variables is a choice of a value for each variable; the partial setting restricted to a subset of the variables will be denoted . A subset is sufcient with respect to setting if the value of is determined by the par. Such a is a proof of the value of under the tial setting setting ; the cheapest proof of the value of under is thus the cheapest sufcient set with respect to . We denote its cost by . An evaluation algorithm is a deterministic rule that queries variables sequentially, basing its decisions on the cost vector and the values of variables already queried. When an evaluation algois run under a setting , it incurs a cost that we denote rithm . We seek algorithms that optimize the competitive ratio
54 6 2 2 2 0 &
#
We provide a fairly complete characterization of the bounds achievable by optimal algorithms on Boolean trees, and focus on three related sets of issues. (1) Tractability of optimal algorithms. We show that for every Boolean tree, and every cost vector, the optimal competitive ratio can be achieved by an efcient algorithm. Specically, the algorithm has a running time that is polynomial in the size of the tree and the magnitudes of the costs. At a high level, the algorithm is based on the following natural Balance Principle: in each step, we try to balance the amount spent in each subtree as evenly as possible. However, to achieve the optimal ratio, this principle must be modied so that in fact we are balancing certain estimates on the lower bound for the cost of the cheapest proof in each subtree. These results are described in Section 2. (2) Dependence of competitive ratio on the structure of . Much of the complexity of the Boolean tree evaluation problem is already contained in the case of complete binary trees of depth , with inputs. When the cost vector is uniform (all input prices are ) the situation has a very simple analysis: any algorithm can be forced to pay , and the cheapest proof always has value . A natural question is therefore the following: exactly -competitive algorithm for every cost vector on the is there is a complete binary tree? More generally, for a given Boolean tree , we could consider the largest competitive ratio that can be forced by any assignment of prices to the inputs:
(
8
7
6 ! 2 2 !0
%
8
#
8
'
&
7
&
"
( 9 8 4 3 ' 21 0 ( )
8
7 8
#$
'
7
7
7
'
'
8
8
8
7& " ' 7& ( "
2 2
#
& 0
!
)
7
7
7 6 5 4 3 ' 21
8
#$
)
7
8
#$
8
7
(
8
&
'
7&
'
& 0 ()
7& "
("
(
We rst consider functions computed by Boolean AND/OR trees: each gate may have arbitrary fan-in, but only one output. Without loss of generality, we may assume that levels of the tree alternate between A ND gates and O R gates. Let such a Boolean tree have leaves labeled by variables . Variable has an associated non-negative cost for reading the value of . We say of leaves a -witness (resp. -witness) for is a minimal set which when set to (resp. ) will cause to evaluate to (resp. ). The cheapest proof which allows one to prove that evaluates to (resp. ) is always some -witness (resp. -witness).
H
We rst investigate the competitive ratio for any Boolean tree (recall the denition of Equation (1)), where the structure of is xed, but leaf prices vary. We propose the following simple lower bound on . For any Boolean tree , let be the largest value for which one can simulate an A ND gate of fan-in using by hardwiring an appropriate set of leaves of to . (Such a is also the size of the largest minterm in boolean function computed by . One can compute by giving all leaves of a value of , replacing the A ND and O R gates of by S UM and M AX functions respectively, and then evaluating the resulting arithmetic circuit.) Consider the following cost vector : whenever , else . Clearly, a -witness for would now have cost exactly , as it would only need to contain one non-zero cost leaf whose value is . On the other hand, any deterministic algorithm could easily be made to pay , simply by setting all but the last non-zero cost leaf queried to have value . Hence, is a lower . bound on One can similarly show that the largest value for which can simulate an O R gate of fan-in (or, equivalently, is the size of the largest maxterm in the function computed by ) is also a lower
H H H
H
H
R
H
R
&
&
!
H
H
4
' '
"
R
4
' H&
H
' H&
'R S
H
22
)
R
' &
)
H
" A
&
E
R
H
2
&
R
$#
&
! B A
!
4
&
'
4
4
D
&
!
' H&
' H&
4
4
)
)
H
AA
$# %
4
R
H
4
(a) Threshold trees. Each internal node is a threshold gate; the output is iff at least a certain number of the inputs are . The threshold values for different gates could be different. (b) Game trees. The inputs are real numbers, and nodes are MIN or MAX functions. (c) A common generalization of (a) and (b). The inputs are real -largest numbers and the nodes are gates that return the of their input values. This threshold could be different for different nodes. In all of this, we have been considering deterministic algorithms only. Understanding how much better one can do with a randomized algorithm is a major open direction; this would involve a generalization of earlier results on randomized tree evaluation [7, 11, 14, 15] to the setting in which inputs have prices. (3) Equilibrium prices for a function . Finally, we consider a dual issue, motivated by the following general question. Suppose many individuals are all interested in computing a function on variables , and each is employing an algorithm that adaptively buys information from the vendors that own the val. What is a natural set of market prices arising ues of from this process? There are, of course, many possible answers to this question just as there are many models for the behavior of prices in a competitive market [10]. Intuitively, one would believe that each vendor would try to charge a high price for its input, but not so high as to price itself out of competition. If we further believe that the individuals performing the queries will be using only optimal on-line algorithms, then the vendor of will not want to be priced out of optimal on-line algorithms. Here we describe one set of prices motivated by this intuition; it exhibits an interesting behavior with a concrete formulation. Let us say that a cost vector is ultra-uniform with respect to a tree if, with input prices set according to , every evaluation algorithm achieves the optimal competitive ratio. In other words, the prices are in a state such that there is no reason, from the point of view of competitive analysis, to prefer one algorithm over any other whether an input is queried relies purely on the arbitrary choice of an optimal algorithm by the individual performing the queries. We prove: for every Boolean tree , there is an ultra-uniform cost vector. The construction of this vector is quite natural, and follows a direct balancing principle of its own. These results are described in Section 3. Sorting, Searching and Selection. We also investigate a problem of a very different character, to which the same style of analysis can be applied: suppose we are given a sorted array with positions, and wish to determine whether it contains a particular number . In the unit-price setting, when we simply wish to minimize the number of queries to array entries, binary search solves this problem in queries. at most Now suppose each array entry has a price, and we seek an algorithm of optimum competitive ratio. Here the cheapest proof of membership of is simply a single query to an entry containing ; the cheapest proof of non-membership is a pair of queries to adjacent entries containing numbers less than and greater than , respectively. It is possible to formalize this problem in terms of a function of the type described above, imposing certain constraints on the sets of inputs that are allowed; we omit the details here. We provide an efcient algorithm for this problem that achieves the optimal competitive ratio with respect to any given cost vector. We then consider the associated extremal problem: which cost vector forces the largest competitive ratio? We also give an algorithm for achieving a competitive ratio of any cost vector; this exceeds the competitive ratio for the uniform
H '
cost vector only by lower order terms. Whether the uniform cost vector is in fact extremal remains an interesting open question. These results are described in Section 4. Further Directions. Our approach raises a number of other directions for further work. We now mention some preliminary results and open questions. Sorting items when each comparison has a distinct cost appears to be highly non-trivial. Suppose, for example, we construct an instance of this problem by partitioning the items into sets and , giving each -to- comparison a very low cost, and giving each -to- and -to- comparison a very high cost. We then obtain a very simple non-uniform cost structure in the spirit of the notoriously difcult problem of sorting nuts and bolts. [8] Binary search can be viewed as a one-dimensional version of the problem of searching for a linear separator between red and blue points in dimensions. Determining cheap, query-efcient strategies for this problem becomes much more challenging in high dimensions; we have developed one approach that is based on a VC-dimension analysis, and identied a number of interesting open questions. This raises the general issue of learning hypotheses from priced information. We can also generalize the binary search problem to partially ordered sets. Here it is natural to ask what can be said about good splitters and central elements in a poset, when each item has a cost. Finally, the problem of selecting the largest element among items when each comparison has a cost is also a challenging direction to explore. Finding the median has some of the avor of the sorting problem discussed above; but even nding the maximum is surprisingly non-trivial. We will report our progress on this problem in the full version of the paper.
G&
"
E
H
"
2 2
2 2
E
Theorem 2.2 Let and be as in Lemma 2.1. Then, , and W EAK BALANCE runs in polynomial time and achieves a competitive ratio of . Corollary 2.3 Let ( ) be the leaves corre(resp. sponding to a largest induced A ND (resp. O R) in . Let ) be the cost vector that assigns cost to leaves (resp. ) and cost to all other leaves. If , then is extremal for ; otherwise is extremal for . That is, either or equals . Corollary 2.4 If is a complete binary tree with leaves, . Hence, for such trees, the all-ones cost vector is then extremal. , Remark: For any monotone boolean function one can prove that the following simple algorithm achieves a comfor any cost vector. Pick the cheappetitive ratio of est minterm and maxterm of , and read all variables in the cheaper of the two; if this proves that evaluates to or stop, else replace by the function obtained by setting the variables just read to their values, and continue with . The key to proving the claimed bound is that any minterm-maxterm pair of must share a variable, and hence the algorithm never reads more than minterms or maxterms. How do we compute the cheapest minterm and maxterm? For boolean trees this computation is actually easy, and -competitive althis gives a simple polynomial-time gorithm for boolean tree evaluation, for any cost vector. W EAK BALANCE does not lose a factor in the competitive ratio, and more importantly, generalizing its approach enables us to devise an algorithm BALANCE that is optimal for any given cost vector, as is described in the next Section.
' ' H& )
For a particular vector of costs, the optimal competitive ratio can be much less than , the ratio guaranteed by W EAK BALANCE . These observations lead us to more exact lower bounds and our algorithm BALANCE which, for any tree and cost vector , achieves the optimal competitive ratio . The key to developing this algorithm is to dene certain lower bound functions that are more rened than the minterm-maxterm based lower bounds of W EAK BALANCE . For any Boolean tree and cost vector , we dene functions and representing lower bounds on the cost that any deterministic algorithm must incur in nding a -witness (or -witness, respectively) of of cost at most . These functions imply that for any tree , every deterministic algorithm must have a competitive ratio of at least the maximum of and . Lower Bound Functions. For a Boolean tree , the functions and are computed in a bottom-up manner moving from the leaves to the root of the tree.
!
It is easy to see that is also a lower bound on the expected competitive ratio of any randomized algorithm.
6
These functions are actually functions of pendence for notational convenience.
E
as well; we omit this de-
!
!
5 4
!
3
' &
' &
$
For a leaf
with cost , we have if if
E
"
A " A " 0 ! B B ! ) (
H
H
' H& 0
H
#
)
H
' &
' &
1
' H&
1
)
65 4
' &
"
1$
' &
4
1
1$
' H& 0
2
65 4
1$
"
)
Proof Sketch: We proceed by induction on the size of the tree . Clearly this holds for trees of size . Consider the case where . Let the root of the tree is an A ND node with children be the sizes of the largest induced A ND gates rooted at be the sizes of the largest O R each child node, and let gates. Observe that while . Any -witness for of cost consists of a single -witness (of cost ) for a subtree rooted at some . Now suppose that W EAK BALANCE has spent more than , and yet W EAK BAL on node . This means that for some ANCE has spent less than , the algorithm has spent more than on . Consider accepted from it must be the last recommendation that ; on the other hand, since there is a -witness of cost rooted at that has not been found, by infrom must be such that duction, the recommendation . This is a contradiction, since the balancing rule would require the recommendation from to take precedence over the one from . Hence, if W EAK BALANCE spends at least on , it will uncover any -witness of cost . Now consider the case of a -witness for of cost , which must consist of -witnesses of . By induccost rooted at every child node , with tion, we know that as soon as W EAK BALANCE spends at least on the subtree rooted at , it will uncover the -witness at , upon will be pruned. Thus, which the rest of the subtree rooted at regardless of the balancing, as soon as W EAK BALANCE spends on , the entire -witness will be uncovered. Recall that , and thus , as desired.
!R !
'
'2
R 6 5 4 C&
C
Lemma 2.1 For any Boolean tree , let and be dened (as above) as the sizes of the largest induced A ND and O R, respectively. If there exists a -witness (resp. -witness) of cost , then (resp. ) before nding W EAK BALANCE will spend at most this witness.
!
#2
22
&
$"
FE C
2
E
'
R
4
2 &
H
H
4
%$ 2
4
2 $
"
' H&
# 2
'
'2
' H&
)
&
R 6 5 4 C&
)
2
R
%$ 2
H
H
' H&
G
0
' H&
)
2 $
&
2 R 65 4
' H&
)
R
&
"
0
$"
)
bound on . Thus, is a lower bound on . Somewhat surprisingly this simple lower bound turns out to be tight, as we show by presenting an algorithm with competitive ratio for any setting of leaf costs. The idea behind the algorithm, which we call W EAK BALANCE , is the following: At each node in the tree, we balance the investment on leaves in each of the subtrees scaling this balancing act using the lower bound ideas above. This ensures that we do not leave a cheap proof unexplored in any subtree. Algorithm W EAK BALANCE : Each node in the tree keeps track that the algorithm has incurred in the subof the total cost tree rooted at . At each step, the algorithm decides which leaf to read next by a process of passing recommendations up the tree: Each (remaining) leaf passes on (to its parent) a recommendato read at cost . For an internal node , we will tion consider two cases: (a) Suppose is an A ND node with children and it receives recommendations . Let be the sizes of the largest A ND gates that can be in, respectively. Then duced in the subtrees rooted at passes upward the recommendation such that is minimized; (b) If is an O R node, then the same proreplaced with the sizes of the largest cess occurs with inducible O R gates , and the recommendation passed up. Finally, the root of ward is the one minimizing . This leaf the tree decides on some recommendation is read at cost , and all local total costs s are updated, and the tree is partially evaluated as much as possible from the value of . When the tree is fully evaluated, the algorithm terminates.
'
An analogous argument holds for the case of an O R node, except in this case, balancing is important for nding a -witness, but not for nding a -witness.
2
!
' H&
&
I
) &
2 2 ' ! 2 &
2 2
&
!
4
'
2
&
!
!&
&
!
!
!&
65 4
&
4
R
&'
I
'
R
!R
!
4
!
!
2 & 2 2
!R
4
!
'
&
&
H
& ! ' !
& 2
& 2
2
2
2 R 65 4
"!# "
I
!
!
&
R
!
!
&
!
!
2&
&
R
R
4
&
R
2
H
2&
!
'
R
2R
I
R
!
H
!
' H& '
!
H
R
!
'
)
2 2R 2 2
&
2
!
I
H
& 2 R 65 4
! R 65 4
2 2R
!
R'
!
& &
4
&
I
H
H
&
!
&
#
#
' !&
'
!&
4
!
!
!
4
In Equation (3), the operator is taken only over those such that there can exist a -witness in of cost at most . If no such exist for a particular , then . In Equation (5), the operator is taken only over those such that a -witness can exist in of cost at most . If no such exist for a particular , then .
## ##
&
#
#
##
We now claim that the above are actually lower bound functions which have some additional nice properties.
!
!
!
R
E
!
'
!&
##
#
4
!
#
!
4
4
' 4 S & ) 4 ( % '
#
!
Later, in the specication of our algorithm, we will also be reand of these functions. Since ferring to the inverse , these functions are not injective, this is loose notation. By we actually mean . In words, is the minimum element in the inverses image of under . Also, for and for a subtree ease of notation, we sometimes refer to rooted at a node also as and respectively.
'
#
22
' !&
2!
#
R
4
## 4
R
' !&
&
$
#
!
!
'
#
4
!
4
4
!
Complexity of computing and : The functions and are step functions when is a leaf and therefore it is easy to see that and are also step functions for any Boolean the functions tree . Hence all the functions above have a compact (of complexity polynomial in the number of leaves and the sum of the costs) representation as a table of values and this representation can be computed efciently: It is clear that the operations of Equations (2) and (4) can be performed efciently. For Equations (3) and (5), it is not difcult to see that by representing all functions as a table of values, it is possible to calculate them in time polynomial in the sum of the costs of the leaves.
' !&
' !&
&
(
$
$
' !&
$
!
Remark: It is easy to see that the denitions above imply (resp. ) if has no -witness (resp. -witness) of cost or less.
' !&
##
#
' !&
R
##
$
##
#
(5)
4S
#
!
#
!
(4)
!
#
$
' & &
1$
'
&
' &
$
4
$
'
1
1
65 4
' &
% $ # " !
&
' &
1$
$
' &
$ ' 1 &
% $ # " $ !
98 4
1
H
$
' !&
1
(2)
is an O R node: Here the situation is exactly reversed from that of an A ND node. Thus, we dene
$
2 # 2#
$
E
(3)
!
4
(2)
Proof: The proof works by inductively moving upward from the leaves to the root of the entire tree . For the leaves, the claim of the Proposition is clearly satised; if is the cost of the leaf, then the cost of a -witness and -witness are both . Unless an algorithm incurs a cost of , the adversary can always set the leaf to be when it is queried thereby creating a -witness of cost , and can instead set it to in which case there is no -witness at all (and therefore trivially every -witness has cost more than ). Suppose is a subtree whose root is an A ND node with subrooted at its children. We want to prove that, trees assuming and satisfy the conditions of the Proposition, the denition of and as per the Equations (2) and (3) above also satises the requirement of the Proposition. We rst consider the case when the algorithm is trying to nd a -witness of cost at most . Note that since is an A ND node, the -witness is simply a -witness of one of the subtrees . The adversary strategy to hide a -witness of cost at most is as follows: The basic idea is to use, for each subtree , the strategy for guaranteed by induction. More specically, for the rst subtrees (excluding for some ) for which the algorithm ends up spending an amount at least , ensure (using part (2) of the of cost at inductive hypothesis) that there is no -witness for most . For the last subtree , use the inductive strategy for to hide a -witness of cost till the algorithm spends . which is Now suppose an algorithm has spent a total cost less than the lower bound function as per , such that the Equation (2). Hence there exists a , algorithm has spent less than on , and hence the above adversary strategy ensures that the algorithm has not found a witness for . It is also clear that the adversary has the option of either extending the partial assignment so that a -witness of cost at most exists, or so that every -witness for has cost more than . Now we consider the case when the algorithm is trying to nd a -witness of cost at most . We may assume that for otherwise the statement of the Proposition holds vacuously. Note that a -witness of cost for consists of -witnesses of for cost for with . Let us pick for which the maximum in Equation (3) is attained. By our assumption of cost at most on Equation (3), there exist -witnesses for for every . The adversary strategy now is as follows: subtrees (excluding for some ), for for the rst which the algorithm incurs a cost of at least , the adversary causes to evaluate to through a -witness of cost at most (using the strategy for each subtree guaranteed by the induction hypothesis), and thus it reduces the value of to the value of . to Meanwhile, for , the adversary also uses the strategy for hide a witness of cost until the algorithm spends . As long as any algorithm has incurred a cost (strictly) less than , this strategy leaves the adversary with the option of either creating a -witness of cost at most or ensuring that every -witness of has cost more than . This completes the proof for the case when
! !
!
4
!
H
4
!
# 2
#
4
!
#
'
#
&
4
' &
$
4
65 4
' &
$
' &
4
(1)
is an A ND node: Now, a minimal -witness for consists of exactly one -witness for some subtree. The adversary can thus choose to hide this witness in any of the subtrees, suggesting the bound we dene below. On the other hand, a minimal -witness for consists of -witnesses from each of the subtrees. Thus, the adversarys only choice is to pick such -witnesses in a manner that maximizes any deterministic algorithms expenditure, suggesting the other bound we dene below. Formally, we dene
!
' !&
1
4
' !&
!
1$
4
' !&
1
' !&
H
1$
!
# 2
2 # 2#
E
#
$
#
1
$
H
2
%
!
For a subtree , let denote the root of , and let be the subtrees rooted at the children of . Suppose we already know the functions and , our goal is to compute and from these functions. There are two cases which is an A ND node or an arise now depending upon whether O R node.
(resp. ) Proposition 2.5 If is an arbitrary tree, then is a lower bound on the cost any algorithm must incur in the worst case in order to nd a -witness of cost at most (resp. -witness of cost at most ). More specically, there is an adversary strategy that ensures that, as long as any algorithm has incurred a cost (resp. ): strictly less than (1) It does not nd a -witness (resp. -witness) of cost at most . (2) The partial assignment to the leaves that have been read can be extended so that a -witness (resp. -witness) of cost at most exists, and also be extended so that every -witness (resp. -witness), if any at all, has cost strictly more than .
Observe that this equation is equivalent to:
'
(7) The latter equation gives insight into the lower bound argument, while the former corresponds to the argument for optimality of the modied BALANCE algorithm. The equation for is obtained by
In Equations (6) and (7), the rst max operators are taken over choices of . In Equation (6), the second operator is taken only over choices of such that there can exist -witnesses in of cost at most , respectively. If no such exist for a particular , then the value of the is . Similarly, in Equation (7), the second operator is taken only over choices of such that: (A) there can exist -witnesses in of cost at most , respectively; (B) there exists some such that a -witness can exist in of cost at most . Again, if no such exist for a particular , then the value of the is .
'
&
'
&
'
6 5 4&
$
S &
' &
' &
5 4 6
6 54
" ! # $#
%
6 5 4 ' &
! ' & %
6 5 4 ' &
E
(
" $
1
1
%
Proof: The proof once again works by inductively moving up the tree from the leaves to the root. When just consists of a leaf , the statement of the theorem clearly holds. Now suppose the root of is an A ND node (the other case can be handled similarly) with with subtree rooted at for . children First, suppose BALANCE spends an amount strictly greater than when evaluating , and yet has a -witness of cost at most . Since is an A ND node, is a collection of -witnesses of cost for , , with . By the denition of in Equation (3), this implies that there exists a , , such that BALANCE spends more than on reading leaves in . By induction, however, this implies that has no -witness of cost or less, a contradiction to the existence of . Hence if BALANCE spends more than , then it rules out the possibility of having any -witness of cost or less. We now consider the case of -witnesses. Suppose BALANCE has spent an amount more than and yet of cost ; we will then arrive at a contradicthere is a -witness tion. Using the fact that is an A ND node, the witness is simply a -witness of cost for some , , say for deniteness, for . By induction, we know that BALANCE it is a -witness never spends more than on (or else there could not be a -witness of cost at most ). Since on the whole BALANCE has spent more than , there must exist a , , say , such that BALANCE has spent more than for deniteness on . Now consider the point when BALANCE chose the recommendation from and went above on its expenditure on , so that . At
' !&
## 2
2#
'
2 &
H
Theorem 2.6 If BALANCE when running on spends an amount which is greater than (respectively ), then there exists no -witness (respectively -witness) for which has cost at most . Or, equivalently, if there exists a -witness (resp. -witness) for of cost at most , then BALANCE proves that evaluates to (resp. ) by spending at most (resp. ).
C
, and BALANCE achieves this competitive ratio.
'"
$
#
' &
H
'
'
1
#
$
' !&
!&
4
&
$ 1
' !&
1$
1
4
!
4
1
4
!
$
' !&
4
65 4
H
1
' !&
2
' !&
H&
!
65 4
rithm has a competitive ratio of at least
' &
,
Observe that A ND and O R gates are both threshold gates, i.e., their output is provided sufciently many of its inputs are set to . It turns out the BALANCE algorithm of the previous sections can be modied to competitively evaluate threshold trees as well: a threshold tree is a tree where each internal node is a threshold -gate , where the output of a -gate is if and for some values of only if at least of its inputs are . The values of the threshold can vary over the nodes of the tree. The algorithm for evaluating threshold trees is BALANCE with appropriate lower bound functions dened for threshold gates akin to the functions dened for A ND and O R gates. The structure of witnesses is more general than for Boolean trees, and as a result we need to run two algorithms in parallel (balancing the costs they incur) one of which uses the function and the other for the balancing criterion; this incurs a factor loss in the competitive ratio of the algorithm. We next specify the lower bound functions for general threshold gates. The details of the proof on how and why modied BALANCE works for threshold trees are similar to those given for Boolean trees and are omitted in this version. Lower Bound Function for Threshold Gates: Suppose a thresh-gate at its root and let be the old tree has a subtrees rooted at the children of . We dene
4
'
2 &
4
"
'
2 &
' H& 0
H
)
Corollary 2.7 For any boolean tree ANCE achieves a competitive ratio of
A A B A
and cost vector , BAL .
(6)
H
'
!
1$
I
&
'
4
&
!
!
'
2
!
I
H
4
&
The BALANCE Algorithm. We now show how to use the lower bound functions described above to derive an algorithm, which we call BALANCE , that achieves the best possible competitive ratio. The high level idea behind BALANCE is the same as W EAK BAL ANCE : At each intermediate node, we balance the amount spent on reading leaves in each of the subtrees by balancing we do not necessarily mean that the exact amounts spent are all nearly equal, rather we mean that the costs of the possible witnesses that can still be found in all the subtrees are of nearly equal cost, so that after spending a huge amount, we do not still leave the possibility of there existing a cheap witness in some unexplored part of the tree which in turn will imply a poor competitive ratio. BAL ANCE actually uses the above lower bound functions and for the balancing criterion. The algorithm is formally described in Figure 2. We want to prove that BALANCE indeed achieves the optimal for any Boolean tree and cost vector . competitive ratio For this we prove below that if there is a witness (for evaluating to either or ) of cost at most , then BALANCE discovers the wit. ness by spending a total cost that is at most In conjunction with Proposition 2.5, note that this immediately implies that BALANCE achieves the optimum competitive ratio possible for any deterministic algorithm; indeed any deterministic algo-
H
'
2
!
1$ 4 $ 1
& ' !& ! I
is rooted at an A ND node; the other case when it is rooted at an O R node is handled similarly.
from . But we then have . Thus BALANCE would have never chosen the recommendation from over that of (here we are using the fact at levels where the parent is an A ND node, BALANCE uses the function to decide whose recommendation to take), a contradiction. Hence there cannot be a -witness of cost at most as we supposed, and we are done. this point, it rejected the recommendation which we know satises
$ ' 1 &
1
"
' !&
12
1$
' !&
H
1$
65 4
H
1
4
1
'
!
H
H
H
' !&
I
H
4 '
H
4
H
1$
' !&
'
1$
!
!
' !&
!
' !&
!
'
2 &
' !&
4
1 $ 1
#
!
H
$
H
H
1$
4
' H& 0 !
4
H
2
#
H
!
' !&
H
)
2
1
E
4
H
!
2
1
R
4
4
' !&
!
' !&
65 4
4
H
1
1
$
H R
!
Algorithm BALANCE :
"
Input: A Boolean tree with a cost vector Output: The value of the tree .
H H
on its
leaves.
1. Moving up the tree from the leaves to the root:
.
/* At this point recommendations have passed upward to the root from the leaves. */
'
endWhile Output the value of the tree .
H
Figure 2: The BALANCE Algorithm.
!
!
H
I
3. For all ancestors i.e perform
I
of
in
the total cost incurred on their subtree is increased by .
2
!
&
2. /* Now we are at the root and say it chose a recommendation The value of the leaf is read at a cost of .
Node then propagates the recommendation from (unless is the root in which case goto Step 2)
up to its parent
. */ ,
'
'
I
I
, with (b) Each internal node of the tree that receives recommendations , from its (not yet pruned) children chooses one of its children as follows: (i) If is an A ND node, choose the child with the minimum value of (ii) If is an O R node, choose the child with the minimum value of (ties are broken arbitrarily)
!& !&
2
' & ' $ &
2 2
E
22
E
2
!
!
'
(a) Each leaf
'
2
!
!
2
&
&
H
While
is not fully evaluated
which has not been read or pruned yet passes a recommendation up to its parent. ( is the cost of leaf .)
H
Compute the lower bound functions and for all nodes referring to the inverses of these functions.)
$
I
Let
for all nodes
in the tree. of . (Actually we will only be
I
/* For each node , we keep track of the total cost
incurred on the subtree rooted at . */
.
Theorem 2.8 For any threshold tree and any cost vector , there is a polynomial time algorithm for evaluating with competitive . ratio at most twice
" H H ' H& 0 )
$
'
4
S
&
1!
1$ !
For our algorithm, it is important that these functions be computed in polynomial time; this turns out to be true.
and
can
E
2 $2
$
4
!
2
Proof: The idea is to ensure that the cost of all -witnesses of is the same, say , and similarly that the cost of all -witnesses of is the same, say (the costs need not be equal). We rst claim that any setting of prices satisfying the above property is in fact an ultra-uniform price vector. To see this, note that tree functions are evasive and hence any algorithm can be forced to examine all the leaves, and the nal value of the tree can be set to either or after the last leaf is read. If is the total cost of all the leaves, any algorithm can thus be forced to have a compet. Moreover, any algorithm has a comitive ratio of petitive ratio at most , as the most an algorithm can spend is the total cost of all the leaves, and the adversary incurs a cost at least for both -witnesses and -witnesses. Hence these prices are indeed ultra-uniform. We now describe how to construct prices that ensure the uniformity of the costs of -witnesses and -witnesses. It is easy to
H H
Theorem 3.1 Given a Boolean tree with leaves, one can nd an ultra-uniform price vector for in polynomial (in ) time.
4
We outline an algorithm for searching an element array with competitive ratio bounded by for any cost vector on the elements of the array. Later, we will improve the algorithm to get a competitive ratio bounded by . This proves that the unit price vector is essentially an extremal price vector for binary search, and also that our algorithm is at most off by lower order terms from the true competitive ratio. The algorithm is motivated by two goals: (1) We do not examine costly elements until we have eliminated the possibility of the element lying in an array location occupied by cheaper elements; and (2) to achieve a competitive ratio close to , we mimic binary search by attempting to halve the search interval with every comparison. Unfortunately, the two goals could be contradictory because the only way to halve the search interval might be to examine an expensive element. High-level description of the algorithm. Our algorithm uses two parameters and . Initially costs are grouped geometrically by rounding costs up to the nearest multiple of ; the algorithm considers groups in increasing order of cost. We normalize costs so that the lowest cost is . Let group consist of all elements with cost . The algorithm maintains a search interval , which is the set of possible (contiguous) locations where could lie, and splits into three (contiguous) intervals where the left and right interdo not contain any element of (the current) group and vals the middle interval , referred to as the effective interval, which begins and ends with an element of group . The algorithm maintains the property that does not contain any elements of groups or lower. We repeatedly compare with the group element that is closest to the middle of the effective interval . Such
'
G&
'
E
E
E
&
!
B B ! ) A
E
A
A
Given a Boolean tree with leaves, we ask: how do we fairly price the leaves of so that every on-line algorithm achieves the same competitive ratio? Such a price vector, if one exists, is called an ultra-uniform price vector. Intuitively, it means that the leaves are so evenly priced that at every stage it does not matter which leaf is queried next, from the point of view of the competitive ratio. (Clearly if a leaf is overpriced, an algorithm will defer reading it unless absolutely necessary; and similarly, if a leaf is underpriced it will be read right away). It is far from clear why such a pricing, which appears to be a very strong requirement, should exist at all. We show in this section that such a pricing not only exists, but can also be found efciently.
H H
) ( $ ( ) ( (
H
) ( (
'E
&
H
H
of
have the same cost . When we reach the root of the tree , we have a price vector with the required property. It is clear that this procedure can be implemented to run in time, and thus an ultra-uniform price vector for exists and can be found in polynomial time.
4
4
) ( $ ( ) ( (
#
H
The above theorem also holds for a common generalization of threshold and MIN/MAX trees where the internal nodes are gates that return the largest element for some (the value of could be different for different nodes).
4
H
4
H
H
4
& H 2 2 H 2 H 4 ) ( $ ( ) ( $ (
Theorem 2.9 For any MIN/MAX tree and a cost vector , there is an efcient algorithm that evaluates with a competitive ratio . at most
" H H ' H& 0 ) C
H
#2
2 2
E
H
H
) ( (
R
H
4
H
H
4
) ( $ (
'
4
H
H
H
We can in fact generalize BALANCE to competitively evaluate game trees (also called MIN/MAX trees). A game tree has real values on its leaves and the internal nodes are M IN and M AX functions; our goal is to evaluate the value of the root. For a MIN/MAX tree we use a pair of witnesses, an witness and a -witness, that prove matching lower and upper bounds respectively on the value of the tree. One can then dene appropriate lower bound functions similar to the func(for Boolean trees) respectively, and run two copies tions of BALANCE simultaneously (balancing the cost they incur), one trying to prove a lower bound (on the value of ) and using for balancing, and the other trying to prove a matching upper bound for balancing), till these two bounds match. (and using
4
H
4
H
1
4
(
'
4 S 2 & 4 S
H
writing the above equation with the complement of a -gate is a
instead of -gate.
since
see that if this property holds for a Boolean tree , then it holds for all subtrees of as well, and this actually shows that such a price vector is unique up to scaling. This motivates the construction of prices in a bottom-up fashion, appropriately rescaling the prices as we move up the tree so that when we reach each intermediate node, the cost of all -witnesses and -witnesses of the subtree rooted at that node have the same cost. We begin by setting the prices of all leaves to . As we move up the tree, we maintain, for each node that has been visited, quantities and which represent the uniform costs of all -witnesses and -witnesses respectively in the subtree rooted at just after was visited (these quantities will change as we move further up the tree to s ancestors). Now, suppose we move up the tree and reach an internal node (which we assume for denite(which are ness to be an A ND node) with children O R nodes). Our goal is to construct an ultra-uniform price vector for , the subtree of rooted at , from the ultra-uniform price vectors of the s. Since is an A ND node, a -witness of is simply a -witness of one of the s. Hence in order to make the cost of all -witnesses of equal, we rescale the prices s so that the cost of -witnesses of and of the nodes in the for are all the same. We can achieve this, for instance, by dividing the price vector of the leaves in by . After this rescaling, all -witnesses of have cost , so we set . A -witness of is the union of -witnesses ; after the above rescaling all -witnesses in for have the same cost , and hence all -witnesses
2
1
4
...