In Min-Sum Set Cover (MSSC), we are given a universe on elements and a collection of subsets , with , and the task is to construct a permutation (or list) of elements of . The cost of covering a set (a.k.a. the cover time of ) with a permutation is the position of the first element of in , i.e., . The goal is to minimize the overall cost of covering all subsets of .
The MSSC problem generalizes various NP-hard problems such as Min-Sum Vertex Cover and Min-Sum Coloring and it is well-studied. Feige, Lovasz and Tetali [FLT04] showed that the greedy algorithm, which picks in each position the element that covers the most uncovered sets, is a 4-approximation (this was also implicit in [BBHST98]) and that no -approximation is possible, unless . Several generalizations have been considered over the years with applications in various areas (we discuss some of those problems and results in Section 1.2).
Online Min-Sum Set Cover.
In this paper, we study the online version of Min-Sum Set Cover. Here, the sets arrive online; at time step , the set is revealed. An online algorithm is charged the access cost of its current permutation ; then, it is allowed to change its permutation to at a moving cost equal to the number of inversions between and , known as the Kendall tau distance . The goal is to minimize the total cost, i.e., . This is a significant generalization of the classic list update problem, which corresponds to the special case where for all sets .
Consider a web search engine, such as Google. Each query asked might have many different meanings depending on the user. For example, the query “Python” might refer to an animal, a programming language or a movie. Given the pages related to “Python”, a goal of the search engine algorithm is to rank them such that for each user, the pages of interest appear as high as possible in the ranking (see e.g., [DKNS01]). Similarly, news streams include articles covering different reader interests each. We want to rank the articles so that every reader finds an article of interest as high as possible.The MSSC problem serves as a theoretical model for practical problems of this type, where we want to aggregate disjunctive binary preferences (expressed by the input sets) into a total order. E.g., for a news stream, the universe corresponds to the available articles and the sets correspond to different user types. The cost of a ranking (i.e., permutation on ) for a user type is the location of the first article of interest. Clearly, in such applications, users arrive online and the algorithm might need to re-rank the stream (i.e., change the permutation) based on user preferences.
For the most part, we evaluate the performance of online algorithms by comparing their cost against the cost of an optimal offline solution that knows the input in advance and chooses an optimal permutation . Note that this solution is static, in the sense that it does not change permutations over time. This type of analysis, called static optimality, is typical in online optimization and online learning. It was initiated in the context of adaptive data structures by the landmark result of Sleator and Tarjan [ST85b], who showed that splay trees are asymptotically as fast as any static tree. Since then, it has been an established benchmark for various problems in this area (see e.g. [IM12, BCK03]); it is also a standard benchmark for several other problems in online optimization (e.g., online facility location [F08, Meyerson01], minimum metric matching [GGPW19, KN03, NR17], Steiner tree [NPS11], etc.).
A much more general benchmark is the dynamic Min-Sum Set Cover problem, where the algorithm is compared against an optimal solution allowed to change permutations over time. This problem has not been studied even in the offline case. In this work, we define the problem formally and obtain first results for the online case.
We remark that the online dynamic MSSC problem belongs to a rich class of problems called Metrical Task Systems (MTS) [BLS92]. MTS is a far-reaching generalization of several fundamental online problems and provides a unified framework for studying online problems (we discuss this in more detail in Section 1.2). Indeed, our results suggest that solving the online dynamic MSSC requires the development of powerful generic techniques for online problems, which might have further implications for the broader setting of MTS.
Throughout this paper, whenever we refer to online problems, like Min-Sum Set Cover or list update, we assume the static case, unless stated otherwise.
Previous Work on List Update.
Prior to our work, the only version of online MSSC studied is the special case where for all sets; this is the celebrated list update problem and it has been extensively studied (an excellent reference is [BEY98]). It is known that the deterministic competitive ratio it least and there are several 2-competitive algorithms known; most notably, the Move-to-Front (MTF) algorithm, which moves the (unique) element of to the first position of the permutation, and the Frequency Count algorithm, which orders the elements in decreasing order according to their frequencies.
The dynamic list update problem has also been extensively studied. MTF is known to be 2-competitive [ST85] and there are several other 2-competitive algorithms [Albers98, EY96].
1.1 Our Results
In this work, we initiate a systematic study of the online Min-Sum Set Cover problem. We consider the -uniform case, where all request sets have the same size . This is without loss of generality, as we explain in Section 1.3.
The first of our main results is a tight bound on the deterministic competitive ratio of Online MSSC. We show that the competitive ratio of deterministic algorithms is .
Any deterministic online algorithm for the Online Min-Sum Set Cover problem has competitive ratio at least .
Note that for , this bound evaluates to , which is exactly the best known lower bound for the list update problem.
We complement this result by providing a matching (up to constant factors) upper bound.
There exists a -competitive deterministic online algorithm for the Online Min-Sum Set Cover problem.
Interestingly, all prior work on the list update problem (case ) does not seem to provide us with the right tools for obtaining an algorithm with such guarantees! As we discuss in Section 2, virtually all natural generalizations of successful list update algorithms (e.g., Move-to-Front, Frequency Count) end up with a competitive ratio way far from the desired bound. In fact, even for , most of them have a competitive ratio depending on , such as or even .
This suggests that online MSSC has a distinctive combinatorial structure, very different from that of list update, whose algorithmic understanding calls for significant new insights. The main reason has to do with the disjunctive nature of the definition of the access cost . In list update, where , the optimal solution is bound to serve a request by its unique element. The only question is how fast an online algorithm should upgrade it (and the answer is “as fast as possible”). In MSSC, the hard (and crucial) part behind the design of any competitive algorithm is how to ensure that the algorithm learns fast enough about the element used by the optimal solution to serve each request . This is evident in the highly adaptive nature of the deceptively simple greedy algorithm of [FLT04] and in the adversarial request sequences for generalizations of Move-to-Front, in Section 2.
To obtain the asymptotically optimal ratio of Theorem 1.2, we develop a rounding scheme and use it to derandomize the multiplicative weights update (MWU) algorithm. Our analysis bounds the algorithm’s access cost in terms of the optimal cost, but it does not account for the algorithm’s moving cost. We then refine our approach, by performing lazy updates to the algorithm’s permutation, and obtain a competitive algorithm for online MSSC.
We also observe (in Section 1.3) that based on previous work of Blum and Burch [BB00], there exists a (computationally inefficient) randomized algorithm with competitive ratio , for any . This implies that no lower bound is possible, if randomization is allowed, and gives a strong separation between deterministic and randomized algorithms.
is computationally inefficient since it simulates the MWU algorithm, which in turn, maintains a probability distribution over allpermutations. This motivates the study of trade-offs between the competitive ratio and computational efficiency. To this end, we propose a memoryless algorithm, called Move-All-Equally (), which moves all elements of set towards the beginning of the permutation at the same speed until the first reaches the first position. This is inspired by the Double Coverage algorithm from -server [CKPV91, CL91]. We believe that achieves the best guarantees among all memoryless algorithms. We show that this algorithm can not match the deterministic competitive ratio.
thm:mae-lb The competitive ratio of the Move-All-Equally algorithm is .
Based on Theorem LABEL:thm:mae-lb, we conjecture that an guarantee cannot be achieved by a memoryless algorithms. We leave as an open question whether has a competitive ratio , or a dependence on is necessary. To this end, we show that the competitive ratio of is at most (see Section 4 for details).
Dynamic Min-Sum Set Cover.
We also consider the dynamic version of online MSSC. Dynamic MSSC is much more general and the techniques developed for the static case do not seem adequately powerful. This is not surprising, since the MWU algorithm is designed to perform well against the best static solution. We investigate the performance of the algorithm. First, we obtain an upper bound on its competitive ratio.
thm:mae-dyn-ub The competitive ratio of the Move-All-Equally algorithm for the dynamic online Min-Sum Set Cover problem is .
Although this guarantee is not very strong, we show that, rather surprisingly, it is essentially tight and no better guarantees can be shown for this algorithm.
thm:mae-dyn-lb For any , the competitive ratio of the Move-All-Equally algorithm for the dynamic online Min-Sum Set Cover problem is .
This lower bound is based on a carefully crafted adversarial instance; this construction reveals the rich structure of this problem and suggests that more powerful generic techniques are required in order to achieve any guarantees. In fact, we conjecture that the lower bound of Theorem 1.1 is the best possible (ignoring constant factors) even for the dynamic problem and that using a work-function based approach such a bound can be obtained.
1.2 Further Related Work
Multiple Intents Re-ranking.
This is a generalization of MSSC where for each set , there is a covering requirement , and the cost of covering a set is the position of the -th element of in . The MSSC problem is the special case where for all sets . Another notable special case is the Min-Latency Set Cover problem, which corresponds to the other extreme case where [HL05]. Multiple Intents Re-ranking was first studied by Azar et. al. [AGY09], who presented a -approximation; later -approximation algorithms were obtained [BGK10, SW11, ISZ14]. Further generalizations have been considered, such as the Submodular Ranking problem, studied by Azar and Gamzu [AG11], which generalizes both Set Cover and MSSC, and the Min-Latency Submodular Cover, studied by Im et.al [INZ16].
Prediction from Expert Advice and Randomized MSSC.
In prediction from expert advice, there are experts and expert incurs a cost in each step. A learning algorithm decides which expert
to follow (before the cost vectoris revealed) and incurs a cost of . The landmark technique for solving this problem is the multiplicative weights update (MWU - a.k.a. Hedge) algorithm. For an in-depth treatment of MWU, we refer to [LW94, FS97, AHK12].
In the classic online learning setting, there is no cost for moving probability mass between experts. However, in a breakthrough result, Blum and Burch [BB00] showed that MWU is -competitive against the best expert, even if there is a cost for moving probability mass between experts. By adapting this result to online MSSC (regarding permutations as experts), we can get an (inefficient) randomized algorithm with competitive ratio , for any constant . A detailed description is deferred to the full version of this paper.
Metrical Task Systems and Online Dynamic MSSC.
The online dynamic Min-Sum Set Cover problem belongs to a rich family of problems called Metrical Task Systems (MTS). In MTS, we are given a set of states and a metric function specifying the cost of moving between the states. At each step, a task arrives; the cost of serving the task at state is . An algorithm has to choose a state to process the task. If it switches from state to state and processes the task there, it incurs a cost . Given an initial state and a sequence of requests, the goal is to process all tasks at minimum cost.
It is easy to see that the online version of dynamic MSSC problem is a MTS, where the states correspond to permutations, thus , and the distance between two states is their Kendall tau distance. For a request set , the request is a vector specifying the cost for every permutation .
Several other fundamental online problems (e.g., -server, convex body chasing) are MTS. Although there has been a lot of work on understanding the structure of MTS problems [BLS92, CL19, BCLL19, KP95, Sit14, Sel20, AGGT20, BEK17, BEKN18], there is not a good grasp on how the structure relates to the hardness of MTS problems. Getting a better understanding on this area is a long-term goal, since it would lead to a systematic framework for solving online problems.
Given a request sequence , for any algorithm we denote or simply the total cost of on . Similarly we denote the total access cost of and the total movement cost of . For a particular time step , an algorithm using permutation incurs an access cost . We denote by the position of element in the permutation .
Online Min-Sum Set Cover.
We focus on the -uniform case, i.e., when all sets have size . This is essentially without loss of generality, because we can always let and add the last unrequested elements in the algorithm’s permutation to any set with . Assuming that , this modification cannot increase the optimal cost and cannot decrease the online cost by more than a factor of .
2 Lower Bounds on the Deterministic Competitive Ratio
We start with a lower bound on the deterministic competitive ratio of online MSSC.
Theorem 1.1. Any deterministic online algorithm for the Online Min-Sum Set Cover problem has competitive ratio at least .
For the proof, we employ an averaging argument, similar to those in lower bounds for list update and -server [MMS90, ST85]. In each step, the adversary requests the last elements in the algorithm’s permutation. Hence, the algorithm’s cost is at least . Using a counting argument, we show that for any fixed set of size and any , the number of permutations with access cost is . Summing up over all permutations and dividing by , we get that the average access cost for is . Therefore, the cost of the optimal permutation is a most , and the competitive ratio of the algorithm at least . The details can be found in Appendix A.
Lower Bounds for Generalizations of Move-to-Front.
For list update, where , simple algorithms like Move-to-Front (MTF) and Frequency Count achieve an optimal competitive ratio. We next briefly describe several such generalizations of them and show that their competitive ratio depends on , even for . Missing details can be found in Appendix A.
: Move to the first position (of the algorithm’s permutation) the element of appearing first in . This algorithm is -competitive when each request consists of the last two elements in . Then, the last element in the algorithm’s permutation never changes and is used by the optimal permutation to serve the entire sequence!
: Move to the first position the element of appearing last in .
: Move to the first positions all elements of (in the same order as in ).
: Move to the first position an element of selected uniformly at random.
, and have a competitive ratio of when each request consists of a fixed element (always the same) and the last element in , because they all incur an (expected for ) moving cost of per request.
The algorithms seen so far fail for the opposite reasons: cares only about the first element and ignores completely the second, and the others are very aggressive on using the second (th) element. A natural attempt to balance those two extremes is the following.
: Let be the position of the first element of in . Move to the first positions of the algorithm’s permutation (keeping their relative order) all elements of appearing up to the position in , for some constant . The bad instance for this algorithm is when each request consists of the last element and the element at position in ; it never uses the th element and the adversary serves all requests with it at a cost of 1.
All generalizations of MTF above are memoryless and they all fail to identify the element by which optimal serves . The following algorithm tries to circumvent this by keeping memory and in particular the frequencies of reqested elements.
: Move to the first position the most frequent element of (i.e., the element of appearing in most requested sets so far).
This algorithm behaves better in easy instances, however with some more work we can show a lower bound of on its competitive ratio. Let be the elements indexed according to the initial permutation and . The request sequence proceeds in phases of length each. The first requests of each phase are , and the last requests consist of and the element at position at the current algorithm’s permutation, for . An optimal solution can cover all the requests by the elements with total cost . The elements are never upgraded by . Hence, the algorithm’s cost is .
3 An Algorithm with Asymptotically Optimal Competitive Ratio
Next, we present algorithm (Algorithm 2) and analyze its competitive ratio. The following is the main result of this section:
The remainder of this section is devoted to the proof of Theorem 1.2. At a high-level, our approach is summarized by the following three steps:
We use as black-box the multiplicative weights update () algorithm with learning rate . Using standard results from learning theory, we show that its expected access cost is within a factor of , i.e., (Section 3.1).
We develop an online rounding scheme, which turns any randomized algorithm into a deterministic one, denoted , with access cost at most (Section 3.2). However, our rounding scheme does not provide any immediate guarantee on the moving cost of .
is a lazy version of that updates its permutation only if ’s distribution has changed a lot. A phase corresponds to a time interval that does not change its permutation. We show that during a phase:
The upper bound on the access cost increases, compared to , by a factor of at most 2, i.e., (Lemma 3.6).
The (expected) access cost of is at least . Since our algorithm moves only once per phase, its movement cost is at most . Thus we get that (Lemma 3.7):
For the upper bound on the moving cost above, we relate how much ’s distribution changes during a phase, in terms of the total variation distance, to the cost of and the cost of our algorithm.
Based on the above properties, we compare the access and the moving cost of against the access cost of and to get the desired competitive ratio:
Throughout this section we denote by the total variation distance of two discrete probability distributions , defined as .
3.1 Using Multiplicative Weights Update in Online Min-Sum Set Cover
In this section, we explain how the well-known algorithm [LW94, FS97] is used in our context.
The MWU Algorithm.
Given permutations of elements of , the algorithm has a parameter and a weight for each permutation , initialized at 1. At each time step the algorithm chooses a permutation according to distribution . When request arrives, incurs an expected access cost of
and updates its weights , where ; this is the so-called learning rate of our algorithm. Later on, we discuss the reasons behind choosing this value.
On the Access Cost of MWU.
Using standard results from learning theory [LW94, FS97] and adapting them to our setting, we get that the (expected) access cost of is bounded by . This is formally stated in Lemma 3.1 (and is proven in Appendix B).
For any request sequence we have that
On the Distribution of MWU.
We now relate the expected access cost of the MWU algorithm to the total variation distance among ’s distributions. More precisely, we show that if the total variation distance between ’s distributions at times and is large, then has incurred a sufficiently large access cost. The proof of the following makes a careful use of ’s properties and is deferred to Appendix B.
Let be the probability distribution of the MWU algorithm at time . Then,
Let and two different time steps such that . Then,
Next, we present our rounding scheme. Given as input a probability distribution over permutations, it outputs a fixed permutation such that for each possible request set of size , the cost of on is within a factor of the expected cost of the distribution on . For convenience, we assume that is an integer. Otherwise, we use .
Our rounding algorithm is described in Algorithm 1. At each step, it finds the request with minimum expected covering cost under the probability distribution and places the elements of as close to the beginning of the permutation as possible. Then, it removes those elements from set and iterates. The main claim is that the resulting permutation has the following property: any request of size has covering cost at most times of its expected covering cost under the probability distribution .
Let be a distribution over permutations and let be the permutation output by Algorithm 1 on . Then, for any set , with ,
The key step is to show that if the element used by to serve the request was picked during the th iteration of the rounding algorithm, then . Clearly, and the theorem follows. Full proof is in Appendix B.2. ∎
3.3 The Lazy Rounding Algorithm
, presented in Algorithm 2, is essentially a lazy derandomization of . At each step, it calculates the distribution on permutations maintained by . At the beginning of each phase, it sets its permutation to that given by Algorithm 1. Then, it sticks to the same permutation for as long as the total variation distance of ’s distribution at the beginning of the phase to the current distribution is at most . As soon as the total variation distance exceeds , starts a new phase.
The main intuition behind the design of our algorithm is the following. In Section 3.2 we showed that Algorithm 1 results in a deterministic algorithm with access cost no larger than . However, such an algorithm may incur an unbounded moving cost; even small changes in the distribution of could lead to very different permutations after rounding. To deal with that, we update the permutation of only if there are substantial changes in the distribution of . Intuitively, small changes in ’s distribution should not affect much the access cost (this is formalized in Lemma 3.5). Moreover, switches to a different permutation only if it is really required, which we use to bounds ’s moving cost.
Bounding the Access Cost.
We first show that the access cost of is within a factor of from the expected access cost of (Lemma 3.6). To this end, we first show that if the total variation distance between two distributions is small, then sampling from those distributions yields roughly the same expected access cost for any request . The proof of the following is based on the optimal coupling lemma and can be found in Appendix B.3.
Let and be two probability distributions over permutations. If that , for any request set of size , we have that
We are now ready to upper bound the access cost of our algorithm.
Bounding the Moving Cost.
We now show that the moving cost of is upper bounded by the expected access cost of .
moves at the end of a phase incurring a cost of at most . Let and be the starting times of two consecutive phases. By the definition of , . By Lemma 3.3, we have that the access cost of during and is at least . We get that
Note that to a large extent, our approach is generic and can be used to provide static optimality for a wide range of online problems. The only requirement is that there is a maximum access cost and a maximum moving cost ; then, we should use MWU with learning rate and move when . Here we used and . The only problem-specific part is the rounding of Section 3.2. We explain the details in Appendix B. We believe it is an interesting direction to use this technique for generalizations of this problem, like multiple intents re-ranking or interpret known algorithms for other problems like the BST problem using our approach.
4 A Memoryless Algorithm
In this section we focus on memoryless algorithms. We present an algorithm, called Move-All-Equally (MAE), which seems to be the “right” memoryless algorithm for online MSSC. MAE decreases the index of all elements of the request at the same speed until one of them reaches the first position of the permutation (see Algorithm 3). Note that belongs to the Move-to-Front family, i.e., it is a generalization of the classic MTF algorithm for the list update problem. admits two key properties that substantially differentiate it from the other algorithms in the Move-to-Front family presented in Section 2.
Let denote the element used by to cover the request . always moves the element towards the beginning of the permutation.
It balances moving and access costs: if the access cost at time is , then the moving cost of is roughly (see Algorithm 3). The basic idea is that the moving cost of can be compensated by the decrease in the position of element . This is why it is crucial all the elements to be moved with the same speed.
First, we show that this algorithm, besides its nice properties, fails to achieve a tight bound for the online MSSC problem.
In the lower bound instance, the adversary always requests the last elements of the algorithm’s permutation. Since MAE moves all elements to the beginning of the permutation, we end up in a request sequence where disjoint sets are repeatedly requested. Thus the optimal solution incurs a cost of per request, while MAE incurs a cost of per request (the details are in Appendix C) . Note that in such a sequence, MAE loses a factor of by moving all elements, instead of one. However, this extra movement seems to be the reason that MAE outperforms all other memoryless algorithms and avoids poor performance in trivial instances, like other MTF-like algorithms.
Let denote the set of elements used by the optimal permutation on a request sequence such that . That means, has those elements in the beginning of its permutation, and it never uses the remaining elements. Consider a potential function being the number of inversions between elements of and in the permutation of (an inversion occurs when an element of is behind an element of ). Consider the request at time and let be the access cost of .
Let be the element used by to serve . Clearly, in the permutation of MAE, passes (i.e., changes relative order w.r.t) elements. Among them, let be the set of elements of and the elements of . Clearly, and . We get that the move of changes the potential by . The moves of all other elements increase the potential by at most . We get that
Since the cost of MAE at step is no more than , we get that the amortized cost of per request is . This implies that for all sequences such that uses all elements of with same frequencies (i.e, the pays on average per request), incurs a cost within factor from the optimal. Recall that all other MTF-like algorithms are competitive even in instances where uses only one element!
While this simple potential gives evidence that is -competitive, it is not enough to provide satisfactory competitiveness guarantees. We generalize this approach and define the potential function , where is the position of element at round and are some non-negative coefficients. The potential we described before is the special case where for all elements of and for elements of .
By refining further this approach and choosing coefficients according to the frequency that uses element to serve requests (elements of high frequency are “more important” so they should have higher values ), we get an improved upper bound.
t:move_all_static The competitive ratio of algorithm is at most .
Note that this guarantee is and . The proof is based on the ideas sketched above but the analysis is quite involved and is deferred to Appendix C.
5 Dynamic Online Min-Sum Set Cover
In this section, we turn our attention to the dynamic version of online MSSC. In online dynamic MSSC, the optimal solution maintains a trajectory of permutations and use permutation to serve each request . The cost of the optimal dynamic solution is , where denotes the optimal permutation trajectory for the request sequence that minimizes the total access and moving cost.
We remark that the ratio between the optimal static solution and the optimal dynamic solution can be as high as . For example, in the sequence of requests , the optimal static solution pays , whereas the optimal dynamic solution pays by moving the element that covers the next requests to the first position and then incurring access cost . The above example also reveals that although Algorithm 2 is -competitive against the optimal static solution, its worst-case ratio against a dynamic solution can be .
As a first study of the dynamic problem, we investigate the competitive ratio of Move-All-Equally (MAE) algorithm from Section 4. We begin with an upper bound.
The approach for proving Theorem LABEL:thm:mae-dyn-ub is generalizing that exhibited in Section 4 for the static case. We use a generalized potential function ; i.e, the multipliers may change over time so as to capture the moves of . To select coefficients we apply a two-level approach. We observe that there is always a 2-approximate optimal solution that moves an element of to the front (similar to classic MTF in list update). We call this . We compare the permutation of the online algorithm with the permutation maintained by this algorithm; at each time, elements the beginning of the offline permutation are considered to be “important” and have higher coefficients . The formal proof is in Appendix D.
Next, we show an almost matching lower bound.
Sketch of the Construction.
The lower bound is based on a complicated adversarial request sequence; we sketch the main ideas. Let be an integer. During a phase we ensure that:
There are “important” elements used by ; we call them . In the beginning of the phase, those elements are ordered in the start of the optimal permutation , i.e., . The phase contains consecutive requests to each of them, in order; thus the total number of requests is . brings each element at the front and uses it for consecutive requests; thus the access cost of is (1 per request) and the total movement cost of of order . Over a phase of requests, incurs an overall cost , i.e., an average of per request.
The first positions of the online permutation will be always occupied by the same set of “not important” elements; at each step the last of them will be part of the request set and MAE will move them to the front. Thus the access cost will always be and the total cost more than .
The two properties above are enough to provide a lower bound ; the optimal cost is per request and the online cost . The goal of an adversary is to construct a request sequence with those two properties for the largest value of possible.
The surprising part is that although MAE moves all requested elements towards the beginning of the permutation, it never manages to bring any of the “important” elements in a position smaller than . While the full instance is complex and described in Appendix D, at a high-level, we make sure that whenever a subsequence of consecutive requests including element begins, is at the end of the online permutation, i.e., . Thus, even after consecutive requests where moves it forward by distance , it moves by positions; by making sure that (which is true for some ), we can make sure that does not reach the first positions of the online permutation.
6 Concluding Remarks
Our work leaves several intriguing open questions. For the (static version of) Online MSSC, it would be interesting to determine the precise competitive ratio of the MAE algorithm; particularly whether it depends only on or some dependency on is really necessary. More generally, it would be interesting to determine the best possible performance of memoryless algorithms and investigate trade-offs between competitiveness and computational efficiency.
For the online dynamic MSSC problem, the obvious question is whether a -competitive algorithm is possible. Here, we showed that techniques developed for the list update problem seem to be too problem-specific and are not helpful in this direction. This calls for the use of more powerful and systematic approaches. For example, the online primal-dual method [BN09b] has been applied successfully for solving various fundamental problems [BBN12, BBMN15, BN06, BN13]. Unfortunately, we are not aware of a primal-dual algorithm even for the special case of list update; the only attempt we are aware of is in [tim16], but this analysis basically recovers known (problem-specific) algorithms using dual-fitting. Our work gives further motivation for designing a primal-dual algorithm for list-update: this could be a starting point towards solving the online dynamic MSSC.
In a broader context, the online MSSC is the first among a family of poorly understood online problems such as the multiple intents re-ranking problem described in Section 1.2. In this problem, when a set is requested, we need to cover it using elements; MSSC is the special case . It is natural to expect that the lower bound of Theorem 1.1 can be generalized to , i.e., as grows, we should be able to achieve a better competitive ratio. It will be interesting to investigate this and the applicability of our technique to obtain tight bounds for this problem.
Appendix A Deferred Proofs of Section 2
In this section, we include the proofs deferred from section 2. First, we prove the general lower bound for the competitive ratio of any deterministic online algorithm for the Online Min Sum Set Cover problem.
Theorem 1.1. Any deterministic online algorithm for the Online Min-Sum Set Cover problem has competitive ratio at least .
Let be any online algorithm. The adversary creates a request sequence in which every request is composed by the last elements of the current permutation of . At each round , incurs an accessing cost of at least . Thus for the whole request sequence of requests, .
The non-trivial part of the proof is to estimate the cost of the optimal static permutation. We will count total cost of allstatic permutations and use the average cost as an upper bound on the optimal cost. For any request set , we intend to find the total cost of the permutations for . To do this, we will count the number permutations that have access cost of , for every . For such counting, there are two things to consider. First, in how many different ways we can choose the positions where the elements of are located and second how many different orderings on elements of and of exist. We address those two separately.
For a permutation that incurs an access cost of , it follows that, from the elements in , the first one in is located in position and no other element from the set is located in positions . The other elements of are located among the last positions of . There are different ways to choose the locations of those elements.
Once the positions of elements of have been fixed, there are different ways to assign the elements in those positions, equal to the number of permutations on elements. Similarly, there are different ways to assign elements of to the remaining positions.
Gathering the above, we conclude that the number of permutations that incur access cost exactly for a fixed request is
The latter implies two basic facts:
(since each permutation has a specific cost for request ).
The total sum of access costs for fixed request of size is:
Total-Access-Cost By reordering the terms
where the last equality follows by the fact that (see number above) with and . Hence for a request sequence of length , we get that
We conclude that for any deterministic algorithm , we have:
Lower bounds for various algorithms.
Next, we prove the lower bounds for the competitive ratio of the several online algorithms generalizing the MTF algorithm. For all lower bounds we use request sets of size . Recall that the th element of the permutation for
: Move to the first position (of the algorithm’s permutation) the element of appearing first in .
Lower bound: Let the request sequence , in which contains the last two elements of ’ s permutation at round . Formally, . moves the first element of the request in the first position and in every round the last element in ’ s permutation remains the same (). As a result, pays in each request, whereas has the element in the first position and just pays per request.
: Move to the first position the element of appearing last in .
Lower bound: Let the request sequence , in which each set always contains the last element of and the fixed element . Clearly pays , while by having element in the first place.
: Move to the first positions all elements of (in the same order as in ) .
Lower bound: The same as previous.
: Move to the first position an element of selected uniformly at random.
Lower bound: Let the request sequence , in which each set always contains an element selected uniformly at random from and the fixed element . Therefore elements in the last positions of have probability to be chosen. At each round , moves with probability to the first position of the list, the element of that was randomly selected. Thus at each round , pays with probability , moving cost at least , meaning that the overall expected cost is at least . As a result, the ratio is since pays by keeping element in the first position.
: Let be the position of the first element of in . Move to the first positions of the algorithm’s permutation (keeping their relative order) all elements of appearing up to the position in , for some constant .
Lower bound: Let the request sequence in which contains the th and the th element of the list at round . never moves the last element and thus belongs in all sets . As in first case, this provides an ratio.
: Move to the first position the most frequent element of (i.e., the element of appearing in most requested sets so far).
Lower bound: The request sequence is specifically constructed so that never moves the last elements of the initial permutation .
The constructed request sequence will be composed by sequences of length . Each piece of length will have the following form:
requests (all requests contain ).
for to (additional requests).
After the requests of type 1, the list is the same as the initial one, since has frequency and have frequency . Now consider the requests of type . moves always to the front the element which is in position , since has already been involved in a type request and has greater frequency. Therefore, pays . Repeating the same request sequence times, we can construct a sequence of length . In this request sequence, keeps the element in the first position and the elements in the next positions. Thus, pays for the requests of type and for the requests of type . pays for the requests of type (same as ), but for the requests of type 2. Setting , we get a lower bound for the competitive ratio of , which concludes this section.
Appendix B Deferred Proofs of Section 3
In this section we include the proofs deferred from Section 3.
b.1 Proofs Related to MWU Algorithm
Here we include omitted proofs related to MWU algorithm.
Access Cost of MWU.
We first show that the MWU is -competitive for access costs.
Lemma 3.1. For any request sequence we have that
By the standard results in learning theory [LW94, FS97], we know that for any sequence , the MWU algorithm satisfies
where . Thus, , for any . Using standard inequalities we get that and for any . We finally get that,
Total Variation Distance.
We now proceed on the proofs of lemmas relating the total variation distance of the distribution maintained by the MWU algorithm to its access cost.
Lemma 3.2. Let be the probability distribution of MWU algorithm at time . Then, the probability distribution of the algorithm satisfies
To simplify notation, let