Advice Complexity of Adaptive Priority Algorithms
AAdvice Complexity of Adaptive Priority Algorithms
Joan Boyar ∗ University of Southern Denmark [email protected]
Kim S. Larsen ∗ University of Southern Denmark [email protected]
Denis Pankratov † Concordia University [email protected]
Abstract
The priority model was introduced by Borodin, Rackoff and Nielsen to capture “greedy-like” algorithms. Motivated, in part, by the success of advice complexity in the area of onlinealgorithm, recently Borodin et al. have extended the fixed priority model to include an advicetape oracle. They also developed a reduction-based framework for proving lower bounds againstthis rather powerful model. In this paper, we extend the advice tape model further to thearguably more useful adaptive priority algorithms. We show how to modify the reduction-basedframework in order for it to apply against the more powerful adaptive priority algorithms. Inthe process, we manage to simplify the proof that the framework works, and we strengthen allthe lower bounds by a factor of 2. As a motivation of an adaptive priority model with advice, wepresent a purely combinatorial adaptive priority algorithm with advice for the minimum vertexcover problem on graphs of maximum degree 3. Our algorithm achieves optimality and usesat most 15 n/
46 bits of advice. This advice is provably shorter than what can be achieved byonline algorithms with advice.
Today everybody who has studied algorithms is familiar with an intuitive notion of a greedy algo-rithm. A greedy algorithm adheres to the philosophy succinctly stated as “live for today.” In manydiscrete optimization problems, input can be represented as a sequence of items coming from someinfinite universe, and the output of an algorithm can be represented as a sequence of decisions –one decision per item, for example to accept an item or to reject it. For every input item, a greedyalgorithm makes a locally best choice. It could mean different things in different contexts, but mostoften it means that the algorithm pretends that each input item is the last it is going to receive.The algorithm then makes a choice about that input item in a way that optimizes the objectiveunder that assumption. This is just an intuitive understanding of greedy algorithms, but how arethey defined formally ? One of the earliest attempts to answer this question can be attributed tothe development of the theory of matroids in 1935 by Whitney [31]. More recently, this theory hasbeen extended to greedoids by Korte and Lov´asz [24, 25, 26, 23]. In spite of the profound connec-tion between greedoids and optimization problems admitting optimal greedy algorithms, greedoids ∗ Supported in part by the Independent Research Fund Denmark, Natural Sciences, grant DFF-7014-00041. † Supported in part by Natural Sciences and Engineering Research Council (NSERC) of Canada. a r X i v : . [ c s . D S ] O c t o not give a complete characterization of greedy algorithms. In fact, to this day, almost 85 yearssince the introduction of matroids, there is still no consensus in the research community as to aformal definition of greedy algorithms.Priority algorithms were introduced by Borodin, Nielsen, and Rackoff [9] in an attempt to formal-ize “greedy-like” or “myopic” algorithms. This model has been studied in the context of manycombinatorial optimization topics, including the classic graph problems [1, 11, 6, 2], makespanminimization [30], satisfiability [29], auctions [8], and general results, present in many of the abovecontributions as well as in [27]. Many classical greedy algorithms have a simple structure consist-ing of two components: (1) a sorting/ordering/priority component, and (2) an online/irrevocabledecisions component. The second component was described in the previous paragraph, while thefirst component determines the order in which the items are processed by that second component.Priority algorithms have this structure and they come in two flavors: fixed and adaptive. Weillustrate these models with two well known examples.First, consider the earliest finishing time (EFT) algorithm for the interval scheduling problem. Theuniverse of input items is U = { ( s, f ) | s, f ∈ Q and 0 ≤ s < f } . An input instance is a finitesubset I ⊂ U . The EFT algorithm can be thought of as ordering the entire universe U (by ascendingfinishing times f ) prior to seeing any of the inputs . The adversary then feeds the input I to thealgorithm, but in the order specified by the algorithm . The algorithm makes an irrevocable decisionabout each new arriving item, namely, accept the interval if it does not overlap the partial solutionso far, and reject it otherwise. This describes the typical framework of fixed priority algorithms.An extension of this basic setup leads to adaptive priority algorithms – those algorithms that canchange the ordering of the universe after processing each input item. An example of an adaptivepriority algorithm is Prim’s algorithm for the minimum spanning tree problem. The universeconsists of triples U = { ( u, v, w ) | u, v ∈ N , w ∈ Q , u (cid:54) = v } where ( u, v ) indicates an edge betweenvertices u and v , while w is the weight of this edge. Prim’s algorithm orders edges by increasingweight, but it has to maintain a single connected component. Thus, the algorithm gives higherpriority to edges incident to vertices already added to the solution. Since the set of vertices in thesolution keeps growing, the ordering (the priority function) keeps changing while input items arebeing processed.The priority model has a lot in common with the model of online algorithms. Priority algorithmscan be seen as either extending the power of online algorithms by allowing a limited ordering ofinput items, or as limiting the power of adversary by not allowing it full control over the orderof items. An online algorithm assumes no knowledge of future input items and has no controlover the order, in which the items arrive. Nonetheless, an online algorithm is required to make an irrevocable decision for each input item. The assumption that an online algorithm does not seethe future at all is quite restrictive and in many cases impractical. It is often the case that someinformation about the input sequence is known in advance, e.g., its length, the largest weight of anitem, etc. An information-theoretic way of capturing this side knowledge is given by the advice tapemodel of Hromkoviˇc et al. [19] (further developed in B¨ockenhauer et al. [5]). In this model, an allpowerful oracle that sees the entire input sequence creates a short advice string that is written on aninfinite tape. The algorithm uses the advice string in processing the online items. The main objectof interest is the trade-off between the amount of advice and the competitive ratio of an online Other advice models have been proposed either earlier or at around the same time as the advice tape model:helper and answerer models of Dobrev et al. [14], per request model of Emek et al. [15], tree exploration model withadvice of Fraigniaud et al. [16]. “Competitive ratio” is essentially what approximation ratio is called in the area of online algorithms. advice complexity . Often, a short advicestring results in a dramatic improvement over the best competitive ratio that is achievable by anonline algorithm without advice. Of course, a short advice string can be computationally difficultto obtain since the oracle is allowed unlimited power. Advice complexity of online algorithmshas recently become a very active research area – see [10] for a survey on online algorithms withadvice, including an extensive list of articles. Of most relevance to us are results concerning graphalgorithms [3, 12, 13, 18, 17, 21, 22, 28].Recently a superset of the current authors has introduced an extension of a fixed priority modelwith advice [7]. As with online algorithms with advice in the advice tape model, an oracle seesthe entire input and writes an advice string on the tape. The advice is then read by the priorityalgorithm at its discretion during the runtime. The oracle and the algorithm cooperate and theyare fully in agreement in terms of how the advice is generated and used. In this model, we areinterested in the trade-off between the length of the advice and the approximation ratio achievedby such an advice-based algorithm. In addition to introducing this model, [7] also developed ageneral framework for proving lower bounds in this model and applied this framework to severalclassical problems, such as maximum independent set, maximum bipartite matching, vertex cover,etc. That research parallels and extends recent developments and successes in the area of onlinealgorithms with advice. However, that research left open the question of whether the ideas can beextended to an (arguably more useful) adaptive priority model. This paper addresses that question.This paper presents three main contributions. The first contribution is conceptual: we introducethe notion of advice in the adaptive priority model and identify three natural models based onhow the priority function is allowed to depend on the advice. The second contribution is technical:we study the classical vertex cover problem on graphs of maximum degree 3. We present anadaptive priority algorithm with advice that achieves optimality. It was known that adaptivepriority algorithms for this problem cannot achieve optimality without advice [6]. In addition, weshow that online algorithms must use more advice than our algorithm to achieve optimality. Thus,both adaptive priority and advice together can be strictly more powerful than either one can be byitself. Our algorithm is purely combinatorial with an involved analysis. A large part of the proofrelies on a thorough case analysis. This is the most technical of our contributions. The third maincontribution is both technical and conceptual: we extend the general lower bound framework of [7]to work in the most powerful of the newly introduced adaptive priority models with advice. Weimmediately obtain similar results to, but stronger than those in [7] when we apply this frameworkto the same classical problems (independent set, bipartite matching, etc.). In addition, we manageto simplify the proof that the framework works, and we strengthen the lower bounds implied by theframework by a factor of 2. The reason for these improvements is that we noticed that is possible toderive lower bounds by reducing directly from the online problem of binary string guessing insteadof going through an intermediate pair matching problem in the priority model as in [7].The remainder of the paper is organized as follows. Section 2 introduces the three adaptive prioritymodels with advice. In Section 3 we introduce an artificial problem called “thorny path” and showhow upper and lower bounds can be derived in adaptive priority models with advice. In Section 4we present our adaptive priority algorithm for the vertex cover problem on graphs of degree at most3 and analyze its advice complexity. Section 5 presents the extension of the general lower boundframework of [7] to adaptive priority with advice. The paper ends with conclusions and some openproblems in Section 6. 3 Models A request-answer game is specified by the universe of input items U , the universe of decisions D ,the objective function OBJ : U n × D n → R ∪ {±∞} , and the type of a problem which could beeither “maximization” or “minimization”. An input to the request-answer game is a finite multi-setof items from the universe, i.e., X = { x , . . . , x n } where x i ∈ U . We assume that the objectivefunction is invariant under simultaneous permutations of input items and decisions, i.e., for all x , . . . , x n and all d , . . . , d n and all π ∈ S n we have:OBJ( x , . . . , x n , d , . . . , d n ) = OBJ( x π (1) , . . . , x π ( n ) , d π (1) , . . . , d π ( n ) ) . Note that the objective function is actually a family of functions – one for each length of input n ∈ N . The values ±∞ in the objective can be used to specify infeasible inputs. The setting ofrequest-answer games is very general and includes most problems of interest in the areas of onlineand priority algorithms.A function P : U → R is called a priority function . We introduce a short-hand notation max P X :=arg max { P ( x ) : x ∈ X } for the element of highest priority in the multi-set X . In case there aremultiple elements of highest priority, we assume the ties are broken in the adversarial fashion, i.e.,we assume the most unfavorable tie-breaking for our algorithms.A priority algorithm ALG does not see all of the input X at once. Instead, ALG receives X one itemat a time. The priority algorithm controls the order in which X is revealed by specifying priorityfunctions. The next input item from X is revealed according to the specified priority function. Weshall consider priority algorithms in the advice tape model [19, 5].In the advice tape model, there are two cooperating players – the oracle and the algorithm. Theoracle sees the entire input X and writes advice to the algorithm on the infinite advice tape overthe binary alphabet. The contents of the infinite tape are denoted by a , which is an infinite string a a a · · · , where a i ∈ { , } . The algorithm can decide to read zero or more bits from the advicetape (sequentially, from left to right) before making each decision. We use s i to refer to the prefixof the advice tape that has been read so far by the algorithm. The maximum number of advice bitsread, i.e., | s n | , (where the maximum is taken over all inputs of length n ) is the advice complexity of the algorithm. See Algorithm 1 for the template of a priority algorithm with advice. Algorithm 1
Template of a Priority Algorithm ALG with Advice X is the input P is the initial priority function i ← while X (cid:54) = ∅ do x i ← max P i − X read zero or more advice bits from a s i ← the known contents of the advice string d i ← decision of ALG for input x i X ← X \ { x i } P i ← the updated priority function i ← i + 1The priority algorithm is specified by three elements: (1) how the priority functions P i are chosenin each step, (2) how the advice is read, and (3) how the decisions d i are made. The decisions are4lways functions of the input seen so far and the advice read so far, i.e., d i := ALG( x , . . . , x i , s i ) . Depending on the details of (1) we distinguish the following three models.
Model 1.
We allow the priority functions to depend on the input received so far and the adviceread so far P i := P i ( x , . . . , x i , s i ) . Model 2.
We allow the priority functions to depend on the input received so far and the decisionsmade so far P i := P i ( x , . . . , x i , d , . . . , d i ) . Model 3.
We allow the priority functions to depend only on the input received so far P i := P i ( x , . . . , x i ) . Observe that any algorithm that works in Model 2 also works in Model 1 (since the input and advicedetermine the decisions), and similarly any algorithm that works in Model 3 can be simulated byan algorithm in Model 2. Thus, we refer to Model 1 as the strongest model of priority algorithmswith advice, Model 3 as the weakest model, and Model 2 as the intermediate model. Observe thatModels 1 and 2 coincide when advice encodes the decisions to be made about some input items.For example, decisions could be “accept/reject” and the advice could determine exactly what todo when an optimal decision cannot be inferred from past input items.To separate Models 1 and 2, consider the artificial problem of computing the spanning tree with anaverage edge weight as far from the average edge weight in the entire graph as possible. Clearly, onemust either compute the maximum or the minimum spanning tree. One bit of advice is requiredto define a priority function to make the very first decision correctly.We have presented the most general version of priority algorithms, called adaptive , since the P i canadapt to the input being revealed. In the fixed priority algorithms we insist that P i = P for all i ≥ P vs. N P , by introducinginformational bottlenecks. The strengths of this information-theoretic modeling are that it makesthe proven lower bounds stronger and that it makes it possible to prove results that do not dependon unproven assumptions in complexity theory. The main weakness of this information-theoreticmodeling is that algorithms designed might be impractical. However, priority algorithms achievinggood approximation ratios tend to have easily computable priority functions and easily computabledecisions. Unfortunately, when it comes to advice, it is often not easily computable. There is ageneric trick one can use to go from priority algorithms with advice to an offline algorithm withthe same approximation ratio. If the algorithm uses advice of length (cid:96) then one can enumerate5ll 2 (cid:96) advice strings and execute the algorithm on each of them keeping track of the best run.This conversion is only efficient for small values of (cid:96) , but even larger values of (cid:96) might lead tointeresting offline algorithms. This is the case for algorithms that achieve optimality for NP-hardproblems and can lead to exponential time algorithms with improved runtimes compared to bruteforce. This is, indeed, the case for our adaptive priority algorithm (see Section 4) with advice forvertex cover on graphs of maximum degree 3. It uses at most 15 n/
46 bits of advice on graphswith n vertices. Using the generic trick, we obtain an optimal offline algorithm that runs in time2 n poly( n ) < . n poly( n ). This is much better than the naive 2 n poly( n ) brute force method;however, there are other more involved optimal offline algorithms achieving even better runtimes.To the best of our knowledge, the current state of the art offline algorithm for this problem hasruntime ≈ . n poly( n ) [20], but that algorithm does not arise out of a priority algorithm withadvice, and no priority algorithm without advice can achieve an approximation ratio better than4/3 [6].A significant motivation for originally introducing and studying priority algorithms was to develop aframework for proving lower bounds for a large collection algorithms at the same time: Establishingthat no fixed (or adaptive) priority algorithm can attain a certain approximation ratio implies thatone has to look beyond this fairly broad design pattern to possibly discover an algorithm with abetter approximation ratio. We note that this motivation is just as relevant for the design of exactor approximation algorithms using the framework outlined above. We call a graph G a thorny path if its vertices can be arranged in layers, such that each layer exceptthe first has exactly two vertices. One of the vertices in layer i is connected to the two vertices inlayer i + 1, while the other vertex in layer i is not connected to any other vertex except its parent.The first layer is special – it consists of a single vertex, and the last layer is special – it has twovertices which are not connected to any other vertex except their common parent. An example ofa thorny path graph is show in Figure 1. uv ws Figure 1: An example of a thorny path graph.We define the thorny path problem as follows. You are given a graph G which consists of severalcomponents, each of which is a thorny path. You are also given a start vertex s of one of the6omponents of G . Your goal is to construct a path from s to one of the leaves in the last layer.The universe of input items is U = Z . Input item ( u, v, w ) is interpreted as vertex labels such thatvertex u is in some level i and its two children are v and w . The universe of decisions D = { , , ⊥} .Given an input item ( u, v, w ) the decision 0 means to include edge ( u, v ) in the solution, the decision1 means to include edge ( u, w ) in the solution, and the decision ⊥ means to not include any of thetwo edges in the solution. The thorny path problem is parameterized by a single parameter k ∈ N ,which is one less than the number of layers in the thorny path starting with vertex s . We referto the parameterized thorny path problem as the k -thorny path problem. We begin with a simpleobservation. Lemma 3.1
The k -thorny path problem can be solved by an adaptive priority algorithm with k bits of advice in Model 2. Proof
Starting from s use advice bits to decide which of the two children to follow. Adaptivityin the priority function is used to re-sort input items by the ID of the child being followed. (cid:3) Theorem 3.2
The N -thorny path problem cannot be solved by an adaptive priority algorithmwith log N − Proof
Assume that we have (cid:96) adaptive priority algorithms without advice called
ALG , . . . , ALG (cid:96) .We fix n large enough (to be specified later) and let x , . . . , x n ∈ Z \ { } be distinct. Let S be theset of all triples formed from { x , . . . , x n } together with all triples where 1 is the first element of thetriple and the other two elements come from { x , . . . , x n } . We construct a thorny path instance I (with 1 connected component) such that each algorithm ALG , . . . , ALG (cid:96) makes a mistake on I .We construct I iteratively. In step j we construct a subinstance I j that guarantees that algorithm ALG j makes a mistake. The thorny path I j starts at a vertex 1 and ends in two leaves. In additionto I j we keep track of a leaf v j that is going to be extended in step j + 1. We also keep track of aset of input items S j ⊆ S that can be used in the extension of I j . The condition that ALG j makesa mistake on I j also continues to hold no matter how I j is extended with elements from S j .Initially, I is a thorny path consisting of a single vertex 1 and none of the algorithms have madea mistake yet. We have v = 1 and S = S . This is a base case.Assume that we have constructed a thorny path I j out of some items from S j and the leaf of I j to be extended is v j . Moreover each of ALG , . . . , ALG j makes a mistake on I j and continue tomake a mistake no matter how I j is extended by elements from S j . Consider running ALG j +1 oninput I j ∪ S j (in spite of it being an invalid input). In each iteration, either it requests an elementfrom I j , updates the priority function, and makes a decision, or it requests an element from S j .Consider the first time ALG j +1 requests an element from S j . If ALG j +1 made a mistake on anelement from I j by that time, then we can simply take I j +1 = I j , v j +1 = v j , and S j +1 = S j . Allthe properties are easy to verify in this case. Otherwise, let ( x, y, z ) be the first element from S j that is requested by ALG j +1 . Without loss of generality, assume that the decision of ALG j +1 isto accept edge ( x, y ) and not ( x, z ). If x = v j , then we extend I j +1 = I j ∪ { ( x, y, z ) } and S j +1 is S j with all items involving y or x removed, as well as those items that have z as second or thirdcoordinate. Observe that this makes sure that ALG j +1 makes a mistake on item ( x, y, z ) and thisfact is unaffected by further extensions of I j +1 . In this case, we have v j +1 = z . The last case toconsider is when ALG j +1 requests ( x, y, z ) from S j and x (cid:54) = v j . In this case, we also consider anitem ( v j , x, w ) ∈ S j for some w that is different from any other value appearing in the constructionso far. By the way that S j ’s are constructed and taking n large enough, such w is guaranteed toexist. We extend I j +1 = I j ∪ { ( v j , x, w ) , ( x, y, z ) } . Again, without loss of generality, assume that ALG j +1 accepts ( x, y ) rather than ( y, z ). We again set v j +1 = z and S j +1 to be the set S j with7ll items involving x, y, w, v j removed, as well as those items that have z as the second or thirdcoordinate. This guarantees that ALG j +1 makes a mistake on item ( x, y, z ) and continues to makea mistake on this item no matter how I j +1 is extended with elements from S j +1 .Lastly, observe that each S j can be defined by some subset F ⊆ { x , . . . , x n } . Namely, S j consistsof all triples formed from F , as well as triples formed by having the first coordinate equal to v j and the remaining two coordinates come from F . In each iteration going from j to j + 1 at most4 elements are removed from F . Therefore, we can fix n = 4 (cid:96) to guarantee that the constructionterminates only after all algorithms are fooled by the instance.Finally, an algorithm in Model 1 with b bits of advice is equivalent to running 2 b algorithms inparallel. Thus, we have k = 2 b algorithms that can all be fooled simultaneously by an instance ofsize 4 k = 4 · b . Letting N = 2 b +2 we see that log N − (cid:3) Given a simple undirected graph G = ( V, E ), a subset of vertices S ⊆ V is called a vertex cover if every edge is incident to at least one vertex from S . The vertex cover problem is to find avertex cover of minimum possible size. We consider this problem on graphs of maximum degree 3in the online and priority settings. An input item is a vertex together with a complete list of itsneighbors (including those vertices that have not even appeared as part of the input yet); this isknown as the vertex arrival, vertex adjacency model . As mentioned earlier, no adaptive priorityalgorithm without advice can achieve an approximation ratio for this problem better than 4/3 [6].In this section, we show that asymptotically this problem requires at least n/ ≤ n/ ≈ . n bitsof advice in the adaptive priority setting.We begin with the negative result for the online setting . Theorem 4.1
An online algorithm that accepts a minimum size vertex cover on any graph withmaximum degree 3 requires at least ( n − / Proof
The graphs constructed by the adversary will have n = 6 n (cid:48) + 1 vertices, for n (cid:48) ≥
2. Let S = { v , v , . . . , v n (cid:48) } be the first 2 n (cid:48) vertices to arrive. All vertices in S will have degree 2, andtheir neighbors will be vertices never seen before. Each graph G which may be created from thesevertices will have a set I G of independent copies of paths of length two, where the middle vertexwill be in S and its two neighbors will have degree 1. All other vertices will be in another set C G ,which will be a cycle (if there are at least 7 vertices not in I G ), plus one extra vertex, w of degree1, adjacent to some vertex v ∈ C G \ S . The vertex v will have degree 3, the extra vertex will havedegree 1, and all other vertices in C G will have degree 2. Within C G , the paths of length twodefined by vertices in S will be joined by one edge. There will be an even number of vertices from S in I G and an even number in C G . The construction is illustrated in Figure 28 wv Figure 2: The construction used in Theorem 4.1. Here, we have n (cid:48) = 4. The optimal vertex coveris shown in green. Nodes with a single arrow pointing into them are those nodes from S that wereselected to be at odd distance from node v . Nodes with two arrows pointing into them are thosenodes from S that were selected to be at even distance from node v . Here, we have n GI = 4 , n GC = 4 , and r = 2.Let n GI denote | S ∩ I G | and n GC denote | S ∩ C G | , and let n (cid:48) = ( n GI + n GC ) /
2. Note that this graph G has a unique minimum size vertex cover, since the middle vertex of each path in I G is in thatcover, and every other vertex in C G , starting with v is also in that cover. This means that everysecond vertex in S ∩ C G is in that cover, with the neighbor of v not being there. Thus, the optimalvertex cover has size n GI + n GC . The number of vertices in S which are in the optimal vertex coveris n GI + n GC / u ∈ S , all of which have degree 2, ALG must decide whether to accept or rejectthis vertex, without knowing if u is in C I or C G . Of course, within C G , ALG will not know if u will have an even or an odd distance from v .Note that it is possible that n GC = 0. Suppose we want to create a graph G with 0 ≤ r ≤ n (cid:48) vertices from S not in the optimal vertex cover. We can choose any subset R of r vertices in S tobe at odd distances from v in C G . Among the other vertices, r can be placed at the even locationsin C G , and the other 2 n (cid:48) − r can be in I G . (Note that the placement of v is also arbitrary,but we are fixing a placement in this counting.) For fixed r , there are (cid:0) n (cid:48) r (cid:1) , different possibilitiesfor the subset R . In all, there are (cid:80) n (cid:48) r =0 (cid:0) n (cid:48) r (cid:1) different possibilities for the subset R , each with adifferent optimal vertex cover. Any online algorithm which gets the same advice for two of them,must give a suboptimal cover for at least one of them. Thus, such an algorithm needs at leastlog (cid:80) n (cid:48) r =0 (cid:0) n (cid:48) r (cid:1) > log n (cid:48) − = 2 n (cid:48) − n − / S are fixed to be exactly thesame in all instances that we consider, i.e., data items in S do not depend on the choice of R, v, and w . Thus, an online algorithm receiving items from S can only rely on advice to act differentlyon S from instance to instance. (cid:3) Now, we present an algorithm that uses fewer than n/ adaptive priority setting with advice tape , more specifically, in Model 2 as defined in Section 2.The high level idea is to process all degree 1 and degree 3 vertices first. Then we will be left with agraph in which every vertex has degree 2. Such a graph consists of disjoint cycles. Finding a vertexcover in such graphs is easy – we just need to take a slight precaution with regards to odd versuseven cycles. Processing vertices of degree 1 does not require advice – they can be rejected and theirunique neighbors accepted. Thus, the rest of the algorithm boils down to using as little advice aspossible for vertices of degree 3. We use several tricks to avoid giving advice to some vertices of9egree 3. The first trick is to insist that if a vertex of degree 3 does not have to participate ina minimum vertex cover, the corresponding advice bit is to reject this vertex. Rejecting such avertex is always good, as it immediately leads to accepting 3 more vertices (its neighbors) withoutany extra advice. Thus, any vertex of degree 3 which has at least two neighbors in the final vertexcover can be rejected, since otherwise there is another vertex cover no larger than this final one,where that vertex is rejected and all three of its neighbors are accepted. Thus, we observe thatif a vertex v at any point receives the advice “accept”, then it has at most one neighbor in thefinal minimum vertex cover. This is essentially the only way we use the condition that an oraclegives higher preference to rejecting vertices of degree 3 subject to still obtaining a minimum vertexcover. This observation implies that if v is accepted then as soon as one of the neighbors of v isaccepted, we can reject the other neighbors of v . This observation also leads to another trick: ifvertex v of degree 3 receives advice to accept and there is another vertex w of degree 3 such that w and v have at least two neighbors in common, then w can be accepted without advice. This holdsbecause at least two neighbors of v are rejected, so w is going to have a rejected neighbor, and itmust be accepted.The following is a more formal description of the algorithm. The algorithm, ALG processes thevertex with highest priority at any point in time. After it is processed, the degree of each of itsneighbors is decreased by 1. We also provide a schematic illustration of several cases with thefollowing meaning: a vertex with an arrow pointing into it is the one currently being processed,red vertices are rejected, green vertices are accepted, yellow vertices received advice “accept”, andthe status of white vertices is irrelevant to the corresponding case being demonstrated. • The highest priority items are those with a rejected neighbor. They are accepted. • The next highest priority items are those of current degree zero; they are rejected. • The next highest priority items are those of degree 1; they are rejected. • The next highest priority items are those neighbors of a vertex where advice was given (andthe advice was to accept or there would be higher priority vertices), which already have oneaccepted neighbor. They are rejected (since the advice could have been reject if two neighborsneed to be accepted). 10
The next highest priority items are those with degree 3; advice tells whether or not to acceptthem, if we cannot figure it out without advice.If there are at least two minimum size vertex covers (given what has already been acceptedand rejected), one where the vertex is accepted and another where the vertex is rejected, theadvice the oracle gives is to reject.Among the vertices with current degree 3, higher priority is given to those with more neighborsin common with a former degree 3 vertex v for which there was advice to accept. If there are2 or more neighbors in common with such a vertex v , the current vertex must be acceptedbecause it has a neighbor which has been (or will be) rejected (if v had two neighbors whichwere accepted, it could have been rejected).If there are no current degree 3 vertices with a neighbor in common with a former degree 3vertex v for which there was advice to accept, higher priority is given to those which have aneighbor which has already been seen as a neighbor of something else. • The lowest priority items are those of degree 2. After the first of these arrives, we havecycles/chains and follow them by continually giving highest priority to the neighbor of thevertex just processed, accepting every other vertex. The first vertex in a cycle is rejected.When reaching a vertex with current degree zero in this way (the last vertex in the cycle), itis accepted. This leads to accepting two in a row at the end of an odd cycle.The analysis of this algorithm is rather involved, so we present a brief overview first. The high-levelidea is to attribute many edges to each vertex that gets an advice bit. Since there can be only a fewedges in total (3 n/ v receives advice to accept. We have to make sure that an edgeis not attributed twice or more. First, we show that the case where one of the neighbors of v is alsoa neighbor of an already processed vertex does not pose trouble for our argument. This means thatwe can attribute sufficiently many edges to v in this case. The problem is that this argument hasto start somewhere, but what if there are no degree 3 vertices which were neighbors of a previouslyprocessed vertex? This naturally leads to an idea of connected components, which are defined bythe subgraphs induced on the vertices already seen (processed or neighbors of processed vertices).It turns out that if a connected component is large enough then the initial phase of a vertex nothaving neighbors of previously processed vertices gets amortized, so we can still attribute many11dges to each vertex receiving advice on average. To finish the argument it remains to analyzethe cases of small connected components. In principle, the remaining issue is a finite problemand could be done by an exhaustive computer search; however, the possible number of connectedcomponents is still huge. In our estimation, this approach would still require a lot of carefuloptimization and potentially using a large computer cluster to perform such calculations. Thus, wedecided in favor of a careful theoretical analysis, because we can eliminate a lot of possibilities inan ad-hoc manner. In addition, it is easier to verify correctness of our analysis than correctness ofa complicated enumeration algorithm. By a thorough case analysis we are able to show that ouralgorithm manages to use sufficiently few bits of advice in all such cases.The proof very heavily uses the fact that, when a vertex of degree 3 is processed using advice, itstill has degree 3 and none of its neighbors currently have degree 1, since otherwise that neighborwould have already been processed. This leads to referring to “the remaining neighbor” or “thethird neighbor”, which must exist according to this logic. This logic also applies to vertices whichare not themselves neighbors of these vertices of degree 3. The formal proof is given below. Theorem 4.2
The above adaptive priority algorithm ALG with advice works in Model 2 and usesat most 15 n/ ≈ . n bits of advice for simple graphs with n vertices and maximum degree 3. Proof.
The priority functions ensure that, for any rejected vertex, its neighbors are accepted.Advice is read only when a vertex with current degree 3 is processed, and advice of 0 tells ALG toreject, while 1 tells ALG to accept. Assuming that the advice is correct, this algorithm is clearlyoptimal. In addition, since the advice can be deduced from the decisions made, it works in Model2. We now argue that the number s of vertices which need advice is at most 15 n/ < . n .Since the maximum degree is 3, there are at most 3 n/ s edges, so5 s ≤ n/ s ≤ n/
10. Thus, to obtain a result less than n/
3, it is sufficient to show that anaverage of 5 edges are removed for each vertex that gets advice. We do this below, except for thefirst vertex, where only three edges are removed.If the advice for a vertex is reject, that vertex is rejected and its three neighbors are accepted. Atleast five edges must be removed, three to the neighbors, one possibly between neighbors, and oneincident to the third neighbor.For each degree 3 vertex v for which ALG reads an advice bit, 3 edges are removed immediately.The three neighbors, x , y , and z of v each have degree at least 2 just before v is processed, or theywould have already been removed. Assume that one of v ’s neighbors, say x , is also the neighborof some vertex w which was processed previously. The vertex x has degree 1 after v is processed.The other neighbor of x could be either a neighbor of v or w , or some other vertex u . Case 1: the other neighbor (call it y ) of x is another neighbor of v or w : Vertex x is rejected and y is accepted (or vice versa if y also has degree 1 and gets higher priority). One of these verticesis rejected and then the other is accepted. The edge between them is removed. Now the vertex a with highest priority is either the third neighbor of x or w (since there was advice with v and w ,and a neighbor of it has been accepted) or a remaining neighbor of the vertex just accepted. Inthe former case, a is rejected and it has at least one neighbor which is accepted, so one more edgecan be attributed to v . In the latter case, the edge to the remaining neighbor of the vertex justaccepted can be attributed to v . In both cases, five edges have been attributed to v . Case 2: the other neighbor of x is some other vertex u . In this case, x is rejected and u is accepted.The vertex u has at least one neighbor other than x , so there is an additional edge, in addition to12he one from x to u , which is removed and can be attributed to v . Thus, in all cases there are fiveedges attributed to v .Note that we assumed that x was a neighbor of a vertex that had already been processed. If it wasnot, then there were no degree 3 vertices which were neighbors of any vertex previously processed.The connected components defined by the subgraphs induced on the vertices already seen (processedor neighbors of processed vertices), could be disconnected in the original graph, or they could beconnected by paths with degree 2 vertices. A vertex v which is in a component C , but has not yetbeen processed has remaining degree 2, so it will never receive advice.Each component has one vertex (the first processed in the component) with only three edgesattributed to it, and the others have five edges attributed to each of them. Consider the possibilityof small components. Case: a component has one or two vertices that get advice.
A component must have atleast one vertex with advice and at least its three neighbors, so at least four vertices in all. If itonly has one vertex with advice, then at most of the vertices in the component get advice. If twovertices get advice, those two vertices cannot share more than one neighbor, so there are at leastseven vertices in all. In this case at most of the vertices in the component get advice. Case: a component has three vertices that get advice.
If three vertices get advice, the thirdone can share at most one neighbor with each of the other two vertices. If there are at least tenvertices in the component, the ratio is achieved. Otherwise, there are exactly nine vertices. Callthe first two vertices with advice a and b and their shared neighbor x . The vertex x is rejected. Itsremaining neighbor, y , is accepted. This y cannot be a neighbor of the third vertex to get advice,or that vertex would not have had degree 3. Thus, it has to be the “unshared” neighbor of a or b ,say a . After y is accepted, vertex a has an accepted neighbor, so its remaining neighbor is rejected.This remaining neighbor is the shared neighbor with the remaining degree 3 vertex, which then nolonger has degree 3, giving a contradiction to the component containing only nine vertices. Case: a component has at least five vertices that get advice.
Suppose k ≥ k −
1) = 5 k − n/
2, the ratio kn is at most ≈ . Case: a component has exactly four vertices that get advice.
Consider the remaining casewhen we have k = 4, i.e., 4 vertices in a connected component receive advice to accept. Let A denote the set of vertices receiving advice to accept. Let A = { a , a , a , a } and suppose that theorder in which the vertices of A receive advice is, in fact, a , a , a , a . Let S denote the set of allother vertices in the connected component. We say that the type of a vertex v ∈ S is | N ( v ) ∩ A | ,i.e., the number of neighbors of v among the vertices in A . Let k i denote the number of vertices oftype i .Suppose that a vertex v ∈ S has type 3 and suppose that it is adjacent to vertices a i , a i , a i ,with i < i < i . Then after a i and a i receive advice, the degree of v would drop down to 1and it would be eliminated before a i receives its advice. However, eliminating v means that thecurrent degree of a i drops and consequently a i would not be receiving advice. This leads to acontradiction. We conclude that v of type 3 does not exist and therefore k = 0.Each vertex of type 2 is adjacent to two distinct vertices from A . Note that no two of vertices a , a , a , a can have two or more neighbors in common. Thus, no two vertices of type 2 can beadjacent to exactly the same set of two vertices from A . Therefore, k ≤ (cid:0) (cid:1) = 6. Note that eachvertex v of type 2 has to have degree 3, since otherwise after processing the first neighbor a j , its13egree would drop down to 1 and it would get processed before its second neighbor in A . Thesecond neighbor in A then would have its degree decreased and would not receive advice.We observe that k = 12 − k , since the four vertices in A each have three neighbors, and thoseneighbors which are shared among vertices in S are shared by the k vertices of type 2. Our goalis to show that such a connected component has at least 13 vertices. The size of the connectedcomponent is | A ∪ S | = | A | + | S | = 4 + k + k + k = 4 + 12 − k + k . It suffices to show that | S | = 12 − k + k ≥
9. We consider several cases:
Case: k ≤
3. We have | S | ≥ − k ≥ Case: k = 6 , k = 0 . The following description refers to the figure below: a a a a v v v v v v After a , with neighbors v , v , and v , is processed, the algorithm would select a vertex that has oneneighbor in common with a . This is vertex a . Without loss of generality the common neighbor is v . After processing a , the degree of v becomes 1. Then v is rejected and its remaining neighboris accepted. The remaining neighbor cannot be any of the v , . . . , v , since otherwise accepting itwould reduce the degree of either a or a prior to seeing them. Thus, the third neighbor of v has to be a new vertex of type 0. The other neighbors of a are called v and v . The vertex a is processed next, and it must share neighbors with both a and a ; both a and a must shareneighbors with both a and a since all of these neighbors are of type 2 and there are four neighborsof a and a remaining. Say that a is adjacent to v and v . After accepting a , the degrees of v and v both become 1. One of them is rejected first, say v (note that essentially the sameargument works if it was v , switching the roles of a and a , as well as those of v and v ), andits remaining neighbor is accepted. That remaining neighbor cannot be any neighbor of a , or thatwould reduce the degree of a . Since v no longer has any neighbors, only v is possible amongthe type 2 vertices. If v is accepted, though, the remaining neighbor of a is rejected. Since thisremaining neighbor of a is also a neighbor of a , the degree of a is reduced. Thus, the thirdneighbor of v has to have type 0. This third neighbor cannot have been the third neighbor of v ,since otherwise the degree of v would be reduced to 1 when that neighbor was accepted. Afterprocessing a , a , a the neighborhood of a consists of v , v , v , at most two of which could beneighbors of each other. The third neighbor of a , say v must have a third neighbor which cannotbe one of the other type 2 vertices, v , v , or v , since they all had two neighbors among a , a ,and a and have been processed themselves. Thus, the third neighbor of v is of type 0. It is noteither of the previous third neighbors of v and v since these have also already been processed.This implies that k ≥
3, giving at least 13 vertices in the component.
Case: k = 5 , k = 2 . Forthis case, it is only necessary to show that k ≥ a , with neighbors v , v , and v , is processed, the algorithm wouldselect a vertex that has one neighbor in common with a . This is vertex a . Without loss ofgenerality the common neighbor is v . After processing a , the degree of v becomes 1. Then v isrejected and its remaining neighbor is accepted. The remaining neighbor cannot be any of the fourother vertices of type 2 or the vertices of type 1 if they are neighbors of a or a , since otherwiseaccepting it would reduce the degree of either a or a prior to seeing them. Call this vertex u .14ubcase: u is not a neighbor of any vertex in A . Then u has to be a new vertex of type 0. a a a a v v v v v v v u After a is processed, there are four neighbors of a and a that might still be neighbors of a and a . At most one of these four has type 1, so between a and a , they must be adjacent to at leastthree of these vertices. Since, according to the priorities, a has at least as many neighbors alreadyseen as a , it must share at least one neighbor with each of a and a . Suppose, without loss ofgenerality, that a is adjacent to v and v . Both of these are reduced to degree 1 and processedbefore a is processed. One of v and v is processed first and rejected, and its neighbor is accepted.If the accepted neighbor is the other of v (or v ), then v (or v ) is rejected, since a (or a ) cannothave two accepted neighbors. Given the symmetries, assume without loss of generality that theaccepted neighbor is v and v is rejected. In addition, since v is adjacent to a , the remainingneighbor of a , v , is also rejected. Now, the only unprocessed vertices that a can be adjacent toare v and v , so there must be an extra vertex not considered yet, giving 13 vertices.If the accepted neighbor of v or v is not the other of v or v , they each have an edge to someother vertex, u , possibly the same one. That vertex u is accepted, so it cannot be a neighbor of a , or a would not have had degree 3 when it was processed. In addition, it cannot have beenany already processed vertex, since then v or v would have had degree only 1 and been processedbefore a was processed. The only other possibility remaining is that they are adjacent to v (or v ). Then, there are already three neighbors defined for each of v , v , v (or v ), and v . Thus, a is adjacent to v , v , and v (or v ). Note that u cannot have had degree 1 initially, or the degreeof v would have been reduced to 1 before a was processed. If u was adjacent to v (or v ) or v ,then the degree of that vertex would have been reduced to 1 before a was processed, so if thereare only twelve vertices in the component, it is adjacent to v . When a is processed, each of itsthree neighbors must still have an additional neighbor not discussed yet. Since they all three havetwo neighbors already discussed, this is impossible; one of them would get degree larger than 3.Subcase: u is a neighbor of a or a . Suppose for the sake of contradiction that each of the verticesof type 1 has one neighbor in { a , a } . Since a and a share a neighbor, they have five distinctneighbors between them, three of which are type 2. Thus, there are two type 2 vertices, say v and v , which are not neighbors of a or a . For this to happen, both of v and v must be neighborsof both of a and a , but then a would have been accepted without advice. Thus, at least one ofthe vertices of type 1 is a neighbor of a or a .Without loss of generality, assume that u is v . After v is accepted and before a arrives, accordingto the algorithm, v , the remaining neighbor of a is rejected, since a should not have two acceptedneighbors. If v has any neighbor, other than v and a , that neighbor’s degree is decreased by 1,so v has type 1. The vertex v must have some other neighbor than a , since v was not rejectedbefore a was processed. Any such neighbors of v must be accepted before a arrives. Thus, v has type 1 also. Now there are no vertices of type 1 adjacent to a or a , and we know that thiscannot happen. Case: k = 4 , k = 4 . In this case we want to argue that k ≥
1. Let v , v , v , v be the vertices oftype 2, and u , u , u , u be the vertices of type 1. We can split this into further subcases depending15n the number of neighbors of each vertex in A of type 1:Subcase: 3 , , ,
0. This means that one of the a i has 3 neighbors of type 1, another a i has 1 neighborof type 1 and the remaining a i have no neighbors of type 1. Because of other restrictions, this caseis actually impossible. To see this suppose a i is adjacent to u , u , u , and a i is adjacent to u and v , v . Since a i can have only 1 neighbor in common with a i , the neighborhood of a i consists of v , v , v or v , v , v . In either case, a can have at most one neighbor in commonwith each of a and a . This means that a can have at most one neighbor from v , v and atmost one neighbor from v , v , but all of its three neighbors must come from v , v , v , v , whichis impossible. Note that this argument is independent of the order in which the a i receive theadvice. Thus, our assumptions about neighborhoods of a , a , a , a were without loss of generality.This case is illustrated in a figure below (the offending topology – two neighbors in common – ishighlighted in red). a i a i a i a i u u u u v v v v Subcase: 2 , , ,
0. This is impossible similar to subcase 3 , , ,
0. The argument will be completelytopological, based on the types of neighborhoods possible. Assume that the two vertices that havetwo neighbors of type 1 are a i and a i . Suppose that the neighborhood of a i is u , u , v . Theneighborhood of a i is u , u together with some vertex v i . This v i cannot be v , since otherwise,vertices a i and a i would have 3 neighbors in common – v , v , v . Thus, v i (cid:54) = v . Without loss ofgenerality assume that it is v . If a i has v , v as neighbors, then a i can only be adjacent to v and v (since v , v are of type 2 and already have two neighbors among the a i ), but a i has to havethree neighbors among v , . . . , v . Therefore, a i can only be adjacent to one of v , v . Withoutloss of generality assume it is v . Thus, the neighborhood of a i is exactly v , v , v . This impliesthat a i has neighborhood v , v , v , but then a i and a i have two neighbors in common. This isa contradiction. This situation is shown in the figure below. a i a i a i a i u u u u v v v v Subcase: 1 , , ,
1. In this case we assume that a i is adjacent to u i . Each of a i has two neighborsamong v , . . . , v . Without loss of generality assume that a has neighborhood u , v , v . Thevertex a has exactly one neighbor in common with a among v , . . . , v . Without loss of generalityassume that a has neighborhood u , v , v . Thus, v already has two neighbors a and a . Afterprocessing a and a , the degree of v is decreased to 1. It will be rejected and its neighbor willbe accepted. The neighbor of v cannot be any of the v i , since otherwise the degree of a or a would decrease and they would not be receiving advice. It also cannot be u or u for the samereason. If the third neighbor of v is u , then one of u and v will be accepted resulting in v being rejected next. Then, the remaining neighbors of v would be accepted, so there would be noadvice with a or a , whichever is a neighbor of v . This is a contradiction. The only remainingpossibility is that the third neighbor of v is u . Similarly, one of the v and u will be accepted,so the third neighbor of a , namely, v will be rejected. This again results in either a or a being16ccepted without needing advice. This is a contradiction again. The only option to make thissubcase feasible is if the third neighbor of v is some other vertex. But this implies that k ≥ a a a a u u u u v v v v Subcase: 2 , , ,
0. Let a i be the vertex with two type 1 neighbors, a i and a i be the verticeswith one type 1 neighbor each, and a i be the vertex with no type 1 neighbors. Without loss ofgenerality we can assume that the neighborhood of a i is v , v , v . Note that a i cannot have v in its neighborhood, for otherwise either a i or a i would have their v i neighbors contained among v , v , v which would mean that either a i or a i would share at least two neighbors with a i . Thus,the neighborhood of a i can be taken to be u , v , v and the neighborhood of a i is u , v , v . Thismeans that the neighborhood of a i has to be u , u , v . This is shown in the figure below. a i a i a i a i u u u u v v v v After processing a , a , the degree of one of the v i is decreased to 1, it is rejected, and its neighboris accepted (or vice versa). If it is v then { a , a } = { a i , a i } . Then the third neighbor of v cannot be any of the u , u , v , v , v for otherwise it would decrease the degree of either a i or a i prior to them receiving advice. The third neighbor of v cannot be u for otherwise a i would havean accepted neighbor, u or v resulting in rejecting v and decreasing the degree of a i prior to a i receiving advice. Similarly, the third neighbor of v cannot be u . Thus, it has to be a new vertexthat is different from u , . . . , u , v , . . . , v . This implies that k ≥ v , . . . , v , whose degree is decreased to 1 after processing a and a is v . Then { a , a } = { a i , a i } . The argument that k ≥ v . It cannot be u , u , u , v , v , v forotherwise the degree of either a i or a i would decrease prior to them receiving advice. It alsocannot be u for otherwise a i would have an accepted neighbor and then v would be rejected andthe degree of a i would drop prior to it receiving advice. Thus, the third neighbor of v has to bea new vertex different from u , . . . , u , v , . . . , v , and k ≥ v , . . . , v whose degree is decreased to 1 after processing a and a is v ,the analysis is symmetric to the one done in the previous paragraph by exchanging the roles of a i and a i . So we can conclude that k ≥ v , . . . , v whose degree is decreased to 1 after processing a , a is v . In this case, { a , a } = { a i , a i } and we consider the third neighbor of v . It cannot beany of the u , u , v , v , v for otherwise the degree of either a i or a i would drop prior to the vertexreceiving advice. Without loss of generality, assume that the third neighbor of v is u (if it is a newvertex then k ≥ a i would already have an accepted neighbor, u would be rejected prior to processing a i or a i . This means that the remaining neighbor(s) of u would be accepted. This neighbor cannot be u , u , v , . . . , v . Thus, the neighbor is u unless17 ≥
1. Also, u cannot have a third neighbor unless k ≥
1. This topology is depicted in the figurebelow (what happens to the topology after processing a , a is shown on the right): a i a i a i a i u u u u v v v v a i a i u u v v v The next vertex to receive advice is either a i or a i . Their roles are symmetric, so assume it is a i . The degree of v then drops to 1 (since a i has also already been processed), it is rejectedand its neighbor is accepted. Its neighbor cannot be any of u , v , v for otherwise the degree of a i would be decreased prior to it receiving advice. If the third neighbor of v is u , then a i would have one accepted and one rejected neighbor, so v would be rejected prior to a i receivingadvice. Hence, the only option is for the third neighbor of v to be a new vertex that is not among u , . . . , u , v , . . . , v . This implies that k ≥ k = 4 and k = 4 is done since we have shown that in all subcases we have k ≥ End of proof of Theorem 4.2.
In this section, we present a template for proving lower bounds on how much advice is needed for anadaptive priority algorithm to achieve a certain competitive ratio. The results hold in the strongestmodel for adaptive priority algorithms with advice. Many proofs in this section are very similarto those presented in [7]. There are two major differences: (1) the proof of the general frameworkresult proceeds by reducing from string guessing directly, and (2) we show how to handle adaptivepriorities. Thus, we present the proofs here in their entirety for completeness.The following online problem, while seeming artificial has been used extensively in proving lowerbounds for online algorithms with advice. Here we use it for adaptive priority algorithms withadvice.
Definition 5.1
The
Binary String Guessing Problem [4] with known history (2-SGKH) is thefollowing online problem. The input consists of ( n, σ = ( x , . . . , x n )), where x i ∈ { , } . Uponseeing x , . . . , x i − an algorithm guesses the value of x i . The actual value of x i is revealed after theguess. The goal is to maximize the number of correct guesses. (cid:3) B¨ockenhauer et al. [4] provide a trade-off between the number of advice bits and the approximationratio for the binary string guessing problem. This can be used to show that a linear number of bitsof advice are necessary for many problems.
Theorem 5.2 [B¨ockenhauer et al. [4]] For the 2-SGKH problem and any ε ∈ (0 , ], no onlinealgorithm reading fewer than (1 − H ( ε )) n advice bits can make fewer than εn mistakes for largeenough n , where H ( p ) = H (1 − p ) = − p log( p ) − (1 − p ) log(1 − p ) is the binary entropy function.Our template is restricted to binary decision problems since the goal is to derive inapproximabilityresults based on the 2-SGKH problem, where guesses (answers) are either 0 or 1. In our reduction18rom 2-SGKH to a problem B , we assume that we have a priority algorithm ALG with advice forproblem B , with priorities defined by priority functions which may vary between inputs to ALG.The current priority function will generally be referred to as P . Based on ALG, its advice, and itspriority functions, we define an online algorithm ALG (cid:48) with advice (the reduction algorithm) for2-SGKH. The reduction is advice-preserving , since ALG (cid:48) only uses the advice that ALG does, nomore. The input items, n, x , x , . . . , x n with x i ∈ { , } , to 2-SGKH arrive in an online manner,so after n arrives, ALG (cid:48) must guess x , and then the actual value of x is revealed. More generally,immediately after the value x i is revealed, ALG (cid:48) must guess x i +1 and then the actual value x i +1 isrevealed. When x n is revealed ALG (cid:48) knows that this is the end of the input. At the end, there issome post-processing to allow ALG (cid:48) to complete its computation.From the value n , ALG (cid:48) initially creates a superset of the input items to problem B , and thoseitems in the subset that is eventually chosen have to be presented to ALG, one at a time, alwaysrespecting the current priority function P . Responses from ALG on some of these input items arethen used by ALG (cid:48) to help it answer 0 or 1 for its current x i . The main challenge is to ensure thatthe input items to ALG are presented in the order determined by the priority functions, which maychange over time.Here, we give a high level description of a specific kind of gadget reduction. A gadget G forproblem B is simply some constant-sized instance for B , i.e., a collection of input items that satisfythe consistency condition for problem B . For example, if B is a graph problem in the vertexarrival, vertex adjacency model, G could be a constant-sized graph, and the universe then containsall possible pairs of the form: a vertex name coupled with a list of possible neighboring vertexnames. Note that each possible vertex name exists many times as the vertex of an input in theuniverse, because it can be coupled with many different possible lists of neighboring vertex names,to make all isomorphic instances of the gadget possible. The consistency condition must apply tothe actual input chosen, so for each vertex name u which is listed as a neighbor of v , it must bethe case that v is listed as a neighbor of u .The gadgets used in a reduction can be thought of as being created in pairs (gadgets in a pairmay be isomorphic to each other, so that they are the same up to renaming), one pair for each x i . The universe of input items corresponding to a gadget pair, ( G a , G r ), must be the same forboth gadgets in the pair. When the first of the input items from ( G a , G r ) has highest priorityaccording to the current P and is given to ALG, that item could theoretically be from either G a or G r . Then, depending on whether the actual value of the next input x i to ALG (cid:48) is 0 or 1 (andpossibly also depending on the form, e.g., the degree for the vertex for a graph), one of G a and G r is chosen, and the remaining input items from that gadget are eventually presented to ALG, whentheir priorities are high enough. The reduction algorithm removes the other input items from theuniverse corresponding to G a and G r once one instance of the gadget pair is chosen.Recall that max P R denotes the first item in a set R according to the current priority function P ,i.e., the highest priority item. For now, assume that ALG responds “accept” or “reject” to anypossible input item. This captures problems such as vertex cover, independent set, clique, etc.Suppose that the universes for the gadget pairs created are ( G , G , . . . , G n ). The universe ofinput items for the n different pairs must be disjoint, so that an input item identifies which gadgetpair it belongs to. Each gadget pair satisfies two conditions: the first item condition, and thedistinguishing decision condition. The first item condition says that the first input item chosenfrom a gadget pair during the execution of ALG, first ( G j ), gives no information about whichof the two gadgets, ( G aj , G rJ ), it is in. Suppose P is the priority function when this first item19as highest priority, and suppose that x i is the value ALG (cid:48) should guess at that point. Then, first ( G j ) = max P G aj = max P G rj (the second equality holds since we assume the two gadgets havethe same input universe). The distinguishing decision condition says that the decision with regardsto item first ( G j ) that results in the optimal value of the objective function in G aj is different fromthe decision that results in the optimal value of the objective function in G rj . One gadget, G aj , ispresented to ALG when x i is revealed to be 0 and the other, G rj , when it is 1.To be concrete, we start with an example reduction from 2-SGKH to Vertex Cover. To illustrate how gadgets are used in the general reductions, we consider the Vertex Cover problem,as in Section 4, in the vertex arrival, vertex adjacency input model, with adaptive priority algorithmswith advice. Thus, for each vertex, when it becomes the highest priority vertex, the priorityalgorithm must decide whether or not to “accept” or “reject” that vertex, where at the end, forevery edge in the graph, at least one of its neighbors must be accepted.We use the construction from [6] (which was reused in [7]) to obtain two pairs of gadgets, one if thehighest priority input item has degree 2 and the other if it has degree 3. For each gadget pair, theuniverse of input items contains the names of seven vertices (the same names are used for both pairsof gadgets), and for each of the vertices all possibilities (names of vertices and lists of neighbors)for both degrees two and three. The gadgets are based on the graphs in Fig. 3, where both graphshave vertex covers of size 3. It is important to keep in mind that the numbers (or rather labels)shown in the figure are for our reference only and do not represent actual input items given to analgorithm. The figure represents the topological structure of the inputs. The actual input itemswould be created out of all consistent labeling of such graphs. To illustrate this point, considervertex 1 in Graph 1. It is adjacent to vertices 2 and 6. The corresponding data item could happento be (1 , { , } ), but it could also be (5 , { , } ), for example. In the latter case, the actual inputvertex 5 would be mapped to the vertex labeled 1 in the figure, vertex 2 would be mapped to label2, and vertex 3 would be mapped to label 6. In total there are 7 × × j . If the first vertex chosen from this gadget pair has degree 2, then it must be possible for thevertex to be either vertex 1 or vertex 2 in Graph 1. Similarly, if the first vertex chosen from thisgadget pair has degree 3, then it must be possible for the vertex to be either vertex 3 in Graph 1 orvertex 1 in Graph 2. Thus, the vertices in this pair could be named v j , v j , . . . , v j . In the universeof inputs items for this pair, each of these 7 vertices could be present as a degree 2 vertex with eachpair of the remaining vertices as its neighbors, and each could also be present as a degree 3 vertexwith each triple of the remaining vertices as its neighbors. Then, no matter which of these verticesgets highest priority first, it is no problem for the reduction algorithm to give that vertex to ALG,use the answer from ALG to give a response of 0 or 1 to the next input, x i to 2-SGKH, receivethe correct value for x i , and choose input items for gadget, G aj or G rj , which will cause ALG toaccept a vertex cover of size 3 if the guess for x i was correct or size 4 otherwise. For each value x i guessed, ALG is given seven input items, so the input length for that problem is 7 n . The numberof gadgets where it obtains a vertex cover of size 3, instead of 4, is exactly the number of inputsto 2-SGKH where ALG (cid:48) guesses correctly. Thus, if ALG (cid:48) makes an error on εn of the x i , ALGobtains an approximation ratio of at most ε .Since Theorem 5.2 limits how many correct guesses ALG (cid:48) can make without a linear amount ofadvice, this limits how good an approximation can be made be ALG without any more advice: Theorem 5.3
For Minimum Vertex Cover and any ε ∈ (0 , ], no adaptive priority algorithmreading fewer than (1 − H ( ε )) n/ ε . In this subsection, we establish two theorems that give general templates for gadget reductionsfrom 2-SGKH – one for maximization problems and one for minimization problems. A high leveloverview was given at the beginning of this section.We let ALG( I ) denote the value of the objective function for ALG on input I . The size of agadget G , denoted by | G | , is the number of input items specifying the gadget. We write OPT( G )to denote the best value of the objective function on G . Recall that we focus on problems wherea solution is specified by making an accept/reject decision for each input item. We write BAD( G )to denote the best value of the objective function attainable on G after making the wrong decisionfor the first item, first ( G ), (the item which was presented to ALG first, due to having highest21riority), i.e., if there is an optimal solution that accepts (rejects) first ( G ), then BAD( G ) denotesthe best value of the objective function given that first ( G ) was rejected (accepted). We say thatthe objective function for a problem B is additive , if for any two non-interacting instances I and I to B (for example, two disjoint connected components in a graph), we have OPT( I ∪ I ) =OPT( I ) + OPT( I ). Theorem 5.4
Let B be a minimization problem with an additive objective function. Let ALGbe an adaptive priority algorithm with advice for B in Model 1. Suppose that for each positiveinteger j , one can construct a pair of gadgets, ( G aj , G rj ), from a common universe of input items, G j , satisfying the following conditions:The first item condition: Let P denote the priority function in effect when first ( G j ) was chosen. first ( G j ) = max P G aj = max P G rj .The distinguishing decision condition: the optimal decision for first ( G j ) in G aj is different from theoptimal decision for first ( G j ) in G rj (in particular, the optimal decision is unique for eachgadget). Without loss of generality, we assume first ( G j ) is accepted in an optimal solution in G aj .The size condition: the gadgets have finite sizes; we let s = max j ( | G aj | , | G rj | ), where the cardinalityof a gadget is the number of input items it consists of.The disjoint copies condition: for j (cid:54) = j and x, y ∈ { a, r } , input items making up G xj and G yj aredisjoint.The gadget OPT and BAD condition: the valuesOPT( G aj ) , BAD( G aj ) , OPT( G rj ) , BAD( G rj )are independent of j , and we denote them byOPT( G a ) , BAD( G a ) , OPT( G r ) , BAD( G r );we assume that OPT( G r ) ≥ OPT( G a ).Define r = min (cid:110) BAD( G a )OPT( G a ) , BAD( G r )OPT( G r ) (cid:111) . Then for any ε ∈ (0 , ), no adaptive priority algorithmreading fewer than (1 − H ( ε )) n/s advice bits can achieve an approximation ratio smaller than1 + ε ( r −
1) OPT( G a ) ε OPT( G a ) + (1 − ε ) OPT( G r ) . Proof
The reduction is given in Algorithm 2.Initially, all possible input items for all n gadget pairs are in the set R of remaining gadgets. Theset Q , of unprocessed input items from the chosen gadgets for all of the gadget pairs where thefirst input item has already been processed, is initially empty. At any point in time, the highestpriority input item still available in either R or Q is presented to ALG. If this item is the firstinput item from a gadget, first ( G j ) from the j th gadget pair, first ( G j ) is presented to ALG. If thenext input to 2-SGKH to be processed is x i , ALG (cid:48) guesses 0 for x i if ALG accepts first ( G j ) and 1 ifALG rejects. If the value of x i is revealed to be 0 (1), all of the input items for G aj ( G rj ), except for first ( G j ) are inserted into Q . All input items corresponding to that gadget pair are then removedfrom R . Now, only the actual input items for the correct gadget in the j th gadget pair remain, andthose not processed yet are in Q . Input items from Q are presented to ALG and removed from Q lgorithm 2 Reduction Algorithm, ALG (cid:48)
Given:
ALG for problem B ; The inputs to 2-SGKH are X = (cid:104) x , . . . , x n (cid:105) Create a set R of input items from n disjoint gadget pair universes { G , G , . . . , G n } Q = ∅ (cid:46) Initialize Q , inputs from gadgets to be processed i = 1 (cid:46) Current index of 2-SGKH input while i ≤ n do Let P be the current priority function for ALG (cid:46) Update the priority function if ( Q = ∅ or max P ( Q ) < max P ( R )) then (cid:46) Highest priority element is from R v = max P R find index j s.t. v ∈ G j (cid:46) v is first ( G j ) present v to ALG answer 0 if ALG answers “accept” and 1 if “reject” receive actual x i if x i = 0 then insert G aj \ { v } into Q else insert G rj \ { v } into Q R = R \ { G j } i = i + 1 else (cid:46) Highest priority element is from Q q = max P Q present q to ALG Q = Q \ { q } while Q (cid:54) = ∅ do (cid:46) Postprocessing to finish inputs for problem B Let P be the current priority function for ALG q = max P Q present q to ALG Q = Q \ { q } − H ( ε )) n (cid:48) bits for the n (cid:48) inputs to 2-SGKH, it is at least (1 − H ( ε )) n/s bits for the n ≤ sn (cid:48) inputs to B .Now we turn to the approximation ratio obtained. We want to lower-bound the number of incorrectdecisions by ALG. We focus on the input items which are first ( G j ) and assume that x f ( j ) is thenext input to 2-SGKH when first ( G j ) is processed. Assume that ALG answers correctly on allinputs that are not first ( G j ) for some j .Note that the gadget pairs are designed such that if the correct answer by ALG for first ( G j ) is“accept”, then G aj is presented to ALG, and if it is “reject”, G rj is given. Since G aj is given when x i = 0 and G rj when x i = 1, and ALG answers “accept” if and only if ALG (cid:48) answers 0, ALGanswers correctly on first ( G xj ), x ∈ { a, r } if and only if ALG (cid:48) answers correctly for x i .We know from Theorem 5.2 that for any ε ∈ (0 , / − H ( ε )) n makes at least εn mistakes on 2-SGKH. Since we want to lower-boundthe performance ratio of ALG, and since a ratio larger than one decreases when increasing thenumerator and denominator by equal quantities, we can assume that when ALG answers correctly,it is on the gadget with the larger OPT-value, G r . For the same reason, we can assume that the “atleast εn ” incorrect answers are in fact exactly εn , since classifying some of the incorrect answersas correct just lowers the ratio. For the incorrect answers, assume that the gadget G a is presented w times, and, thus, the gadget, G r , εn − w times.Denoting the input created by ALG (cid:48) for ALG by I , we obtain the following, where we use thatBAD( G xj ) ≥ r OPT( G xj ) for x ∈ { a, r } . ALG( I )OPT( I ) ≥ (1 − ε ) n OPT( G r )+ w BAD( G a )+( εn − w ) BAD( G r )(1 − ε ) n OPT( G r )+ w OPT( G a )+( εn − w ) OPT( G r ) ≥ (1 − ε ) n OPT( G r )+ wr OPT( G a )+( εn − w ) r OPT( G r )(1 − ε ) n OPT( G r )+ w OPT( G a )+( εn − w ) OPT( G r ) = 1 + w ( r −
1) OPT( G a )+( εn − w )( r −
1) OPT( G r ) w OPT( G a )+( n − w ) OPT( G r ) Taking the derivative with respect to w and setting equal to zero gives no solutions for w , so theextreme values must be found at the endpoints of the range for w which is [0 , εn ].Inserting w = 0, we get 1 + ε ( r − w = εn gives1 + ε ( r −
1) OPT( G a ) ε OPT( G a ) + (1 − ε ) OPT( G r ) . The latter is the smaller ratio and thus the lower bound we can provide. (cid:3)
The following theorem for maximization problems is proved analogously.
Theorem 5.5
Let B be a maximization problem with an additive objective function. Let ALGbe an adaptive priority algorithm with advice for B in Model 1. Suppose that for each positiveinteger j , one can construct a pair of gadgets ( G aj , G rj ) satisfying the conditions in Theorem 5.4.Then for any ε ∈ (0 , ], no adaptive priority algorithm reading fewer than (1 − H ( ε )) n/s advicebits can achieve an approximation ratio smaller than1 + ε ( r −
1) OPT( G a ) ε OPT( G a ) + (1 − ε ) r OPT( G r ) , r = min (cid:110) OPT( G a )BAD( G a ) , OPT( G r )BAD( G r ) (cid:111) . Proof
The proof proceeds as for the minimization case in Theorem 5.4 until the calculation of thelower bound of
ALG( I )OPT( I ) . We continue from that point, using the inverse ratio to get values largerthan one.We use that for x ∈ { a, r } , BAD( G x ) ≤ OPT( G x ) /r . OPT( I )ALG( I ) ≥ (1 − ε ) n OPT( G r )+ w OPT( G a )+( εn − w ) OPT( G r )(1 − ε ) n OPT( G r )+ w BAD( G a )+( εn − w ) BAD( G r ) ≥ (1 − ε ) n OPT( G r )+ w OPT( G a )+( εn − w ) OPT( G r )(1 − ε ) n OPT( G r )+ wr OPT( G a )+ εn − wr OPT( G r ) Again, taking the derivative with respect to w gives an always non-positive result. Thus, thesmallest value in the range [0 , εn ] for w is found at w = εn . Inserting this value, we continue thecalculations from above: OPT( I )ALG( I ) ≥ (1 − ε ) n OPT( G r )+ w OPT( G a )+( εn − w ) OPT( G r )(1 − ε ) n OPT( G r )+ wr OPT( G a )+ εn − wr OPT( G r ) = (1 − ε ) n OPT( G r )+( εn ) OPT( G a )(1 − ε ) n OPT( G r )+ εnr OPT( G a ) = (1 − ε ) r OPT( G r )+ εr OPT( G a )(1 − ε ) r OPT( G r )+ ε OPT( G a ) = 1 + ε ( r −
1) OPT( G a )(1 − ε ) r OPT( G r )+ ε OPT( G a ) The latter is the smaller ratio and thus the lower bound we can provide. (cid:3)
We mostly use Theorems 5.4 and 5.5 in the following specialized form.
Corollary 5.6
With the set-up from Theorems 5.4 and 5.5, we have the following:For a minimization problem, if OPT( G a ) = OPT( G r ) = BAD( G a ) − G r ) −
1, then noadaptive priority algorithm reading fewer than (1 − H ( ε )) n/s advice bits can achieve an approxi-mation ratio smaller than 1 + ε OPT( G a ) .For a maximization problem, if OPT( G a ) = OPT( G r ) = BAD( G a ) + 1 = BAD( G r ) + 1, then noadaptive priority algorithm reading fewer than (1 − H ( ε )) n/s advice bits can achieve an approxi-mation ratio smaller than 1 + ε OPT( G a ) − ε .All of the gadget pairs used in [7] to prove lower bounds in the fixed priority model also work herein the adaptive priority model; there are no additional restrictions used in the proof here. Thereductions done here are directly from 2-SGKH, as opposed to going through the Pair Matchingproblem, as in [7]. This actually makes the proofs simpler in most respects (except for having totake into account changing priority functions), and it means that one does not lose a factor 2 in theamount of advice required. Thus, the results from [7] can be expressed using Table 1 as adaptivepriority algorithm with advice lower bounds: All of the ratios obtained approach 1 as the amountof advice approaches some fraction of n . The extension of the adaptive priority model to the advice tape model leads to many new researchdirections. We consider the following open problems to be of particular interest:25able 1: Summary of results: For a given problem, and any ε ∈ (0 , ], no adaptive priority algorithm(in Model 1) reading fewer than the specified number of bits of advice can achieve an approximationratio smaller than the ratio listed.Problem − H ( ε )) n/ ε − ε Maximum Bipartite Matching (1 − H ( ε )) n/ ε − ε Maximum Cut (1 − H ( ε )) n/ ε − ε Minimum Vertex Cover (1 − H ( ε )) n/ ε Maximum 3-Satisfiability (1 − H ( ε )) n/ ε − ε Unit Job Scheduling with Precendence Constraints (1 − H ( ε )) n/ ε − ε
1. Design and analyze new adaptive priority algorithms with advice for (special cases of) classicaloptimization problems and convert them to offline algorithms by trying all possibilities forthe advice. In particular, are there priority algorithms with advice that lead to faster (interms of the base of the exponent) exact exponential time offline algorithms than the bestknown?2. The previous question also applies to approximation algorithms, when the best known offlineapproximation algorithm is exponential in terms of running time.3. Suggest and investigate other extensions of the adaptive priority framework besides theinformation-theoretic advice tape extension. For instance, one could consider a class of adap-tive priority algorithms where advice is given by an AC0 circuit. What can be said about thepower and limitations of such algorithms?4. More generally, study structural complexity of priority algorithms with advice. What rea-sonable complexity classes can be defined based on advice complexity and approximationratio?5. The lower bounds implied by our reduction-based framework are of the form “constant in-approximability even given linear advice.” Can this framework be extended to handle su-perconstant inapproximability with sublinear advice? More generally, the goal is to designsome framework that could work in this other regime of parameters. A good starting pointwould be to show that maximum independent set cannot be approximated to within n − ε with O (log n ) bits of advice, for any fixed ε ∈ (0 , References [1] Spyros Angelopoulos and Allan Borodin. On the power of priority algorithms for facilitylocation and set cover.
Algorithmica , 40(4):271–291, 2004.[2] Bert Besser and Matthias Poloczek. Greedy matching: Guarantees and limitations.
Algorith-mica , 77(1):201–234, 2017. 263] Maria Paola Bianchi, Hans-Joachim B¨ockenhauer, Tatjana Br¨ulisauer, Dennis Komm, andBeatrice Palano. Online minimum spanning tree with advice.
Int. J. Found. Comput. Sci. ,29(4):505–527, 2018.[4] Hans-Joachim B¨ockenhauer, Juraj Hromkoviˇc, Dennis Komm, Sacha Krug, Jasmin Smula, andAndreas Sprock. The string guessing problem as a method to prove lower bounds on the advicecomplexity.
Theoretical Computer Science , 554:95–108, 2014.[5] Hans-Joachim B¨ockenhauer, Dennis Komm, Rastislav Kr´aloviˇc, Richard Kr´aloviˇc, and TobiasM¨omke. Online algorithms with advice: The tape model.
Information and Computation ,254(1):59–83, 2017.[6] Allan Borodin, Joan Boyar, Kim S. Larsen, and Nazanin Mirmohammadi. Priority algorithmsfor graph optimization problems.
Theoretical Computer Science , 411(1):239–258, 2010.[7] Allan Borodin, Joan Boyar, Kim S. Larsen, and Denis Pankratov. Advice complexity ofpriority algorithms. In , volume 11312 of
Lecture Notes in Computer Science , pages 69–86. Springer, 2018.[8] Allan Borodin and Brendan Lucier. On the limitations of greedy mechanism design for truthfulcombinatorial auctions.
ACM Transactions on Economics and Computation , 5(1):2:1–2:23,2016.[9] Allan Borodin, Morten N. Nielsen, and Charles Rackoff. (Incremental) priority algorithms.
Algorithmica , 37(4):295–326, 2003.[10] Joan Boyar, Lene M. Favrholdt, Christian Kudahl, Kim S. Larsen, and Jesper W. Mikkelsen.Online Algorithms with Advice: A Survey.
ACM Computing Surveys , 50(2):19:1–19:34, 2017.[11] Sashka Davis and Russell Impagliazzo. Models of greedy algorithms for graph problems.
Algorithmica , 54(3):269–317, 2009.[12] Stefan Dobrev, Rastislav Kr´aloviˇc, and Richard Kr´aloviˇc. Advice complexity of maximumindependent set in sparse and bipartite graphs.
Theor. Comput. Syst. , 56(1):197–219, 2015.[13] Stefan Dobrev, Rastislav Kr´aloviˇc, and Euripides Markou. Online graph exploration withadvice. In
SIROCCO , volume 7355 of
LNCS , pages 267–278. Springer, 2012.[14] Stefan Dobrev, Rastislav Kr´aloviˇc, and Dana Pardubsk´a. Measuring the problem-relevantinformation in input.
RAIRO - Theor. Inf. Appl. , 43(3):585–613, 2009. Preliminary versionentitled ”How Much Information about the Future Is Needed?” in SOFSEM’08.[15] Yuval Emek, Pierre Fraigniaud, Amos Korman, and Adi Ros´en. Online computation withadvice.
Theor. Comput. Sci. , 412(24):2642–2656, 2011.[16] Pierre Fraigniaud, David Ilcinkas, and Andrzej Pelc. Tree exploration with advice.
Inf. Com-put. , 206(11):1276–1287, 2008.[17] Barun Gorain and Andrzej Pelc. Deterministic graph exploration with advice.
ACM Trans.Algorithms , 15(1):8:1–8:17, 2019.[18] Magn´us M. Halld´orsson, Kazuo Iwama, Shuichi Miyazaki, and Shiro Taketomi. Online inde-pendent sets.
Theor. Comput. Sci. , 289(2):953–962, 2002.[19] Juraj Hromkoviˇc, Rastislav Kr´aloviˇc, and Richard Kr´aloviˇc. Information complexity of onlineproblems. In
MFCS , volume 6281 of
LNCS , pages 24–36. Springer, 2010.2720] Davis Issac and Ragesh Jaiswal. An $Oˆ*(1.0821ˆn)$-time algorithm for computing maximumindependent set in graphs with bounded degree 3.
CoRR , abs/1308.1351, 2013.[21] Dennis Komm, Rastislav Kr´aloviˇc, Richard Kr´aloviˇc, and Christian Kudahl. Advice complexityof the online induced subgraph problem. In
MFCS , volume 58 of
LIPIcs , pages 59:1–59:13.Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik, 2016.[22] Dennis Komm, Rastislav Kr´aloviˇc, Richard Kr´aloviˇc, and Jasmin Smula. Treasure hunt withadvice. In
SIROCCO , volume 9439 of
LNCS , pages 328–341. Springer, 2015.[23] B. Korte and L. Lov´asz. Greedoids and linear objective functions.
SIAM Journal on AlgebraicDiscrete Methods , 5(2):229–238, 1984.[24] Bernhard Korte and L´aszl´o Lov´asz. Mathematical structures underlying greedy algorithms.In
Proceedings of the 1981 International FCT-Conference on Fundamentals of ComputationTheory , FCT ’81, pages 205–209, London, UK, UK, 1981.[25] Bernhard Korte and L´aszl´o Lov´asz. Structural properties of greedoids.
Combinatorica ,3(3):359–374, Sep 1983.[26] Bernhard Korte and L´aszl´o Lov´asz. Greedoids - a structural framework for the greedy algo-rithm. In William R. Pulleyblank, editor,
Progress in Combinatorial Optimization , pages 221– 243. Academic Press, 1984.[27] Neal Lesh and Michael Mitzenmacher. Bubblesearch: A simple heuristic for improving priority-based greedy algorithms.
Information Processing Letters , 97(4):161–169, 2006.[28] Shuichi Miyazaki. On the advice complexity of online bipartite matching and online stablemarriage.
Inform. Process. Lett. , 114(12):714–717, 2014.[29] Matthias Poloczek. Bounds on greedy algorithms for MAX SAT. In , volume 6942 of
LNCS , pages 37–48. Springer, 2011.[30] Oded Regev. Priority algorithms for makespan minimization in the subset model.
InformationProcessing Letters , 84(3):153–157, 2002.[31] Hassler Whitney. On the abstract properties of linear dependence.