Enikő Kevi

Kim Nguyễn

Thắng

Kevi Enikő

Nguyễn Kim Thắng

Online Covering with Multiple Experts

diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Introduction

The domain of algorithms with predictions [START_REF] Mitzenmacher | Beyond the Worst-Case Analysis of Algorithms, chapter Algorithms with Predictions[END_REF] -or learning augmented algorithms -emerged recently and grown immensely at the intersection of (discrete) algorithm design and machine learning (ML). Combining ML techniques with traditional algorithm design methods enables online algorithms to benefit from predictions that can infer future information from patterns in past data. Online algorithms with predictions can obtain performance guarantees beyond the worst-case analysis and provide fine-tuned solutions to various problems. In the literature, many significant problems have new learning-augmented results, for example, scheduling [START_REF] Lattanzi | Online scheduling via learned weights[END_REF][START_REF] Mitzenmacher | Scheduling with predictions and the price of misprediction[END_REF], caching (paging) [START_REF] Lykouris | Competitive caching with machine learned advice[END_REF][START_REF] Rohatgi | Near-optimal bounds for online caching with machine learned advice[END_REF][START_REF] Antoniadis | Online metric algorithms with untrusted predictions[END_REF], ski rental [START_REF] Gollapudi | Online algorithms for rent-or-buy with expert advice[END_REF][START_REF] Kumar | Improving online algorithms via ML predictions[END_REF][START_REF] Angelopoulos | Online Computation with Untrusted Advice[END_REF], counting sketches [START_REF] Hsu | Learning-based frequency estimation algorithms[END_REF], bloom filters [START_REF] Kraska | The case for learned index structures[END_REF][START_REF] Mitzenmacher | A model for learned bloom filters, and optimizing by sandwiching[END_REF], and metric task systems [START_REF] Antoniadis | Mixing predictions for online metric algorithms[END_REF].

Even though predictions provide a glimpse of the future, there is no mathematical guarantee of their accuracy. Adjusting the algorithm's trust in the predictions is a significant challenge since online algorithms must make irrevocable decisions at each time step. Ideally, if the predictions are accurate, the algorithm should perform well compared to the offline setting. In contrast, if the predictions are misleading, the algorithm should maintain a competitive solution, similar to the online setting where no predictive information is available. In other words, online algorithms with predictions are expected to bring the best of both worlds: mathematical performance guarantees of classical algorithms and good future prediction capabilities of machine learning methods.

Predictions can come from multiple sources (heuristics, oracles, randomized methods, etc.), but we ignore their nature and call all of them experts. An algorithm's consistency with the experts' suggestions is typically measured by comparing the algorithm's result with the solution of the best expert. A representative example is the popular notion of regret in online learning, which fueled the development of many powerful algorithms and techniques.

A natural research question is whether it is possible to design competitive algorithms with mathematical performance guarantees with a stronger benchmark than the best expert. Comparing an algorithm with a stronger benchmark could provide deeper insights into the learning process and give better ways of exploiting the experts' predictions.

Taking a broader view, we can study whether combining predictions of several experts is similar to combining multiple online algorithms and whether we can expect to achieve better solutions with the combination. Assuming that we do not know in advance which of the given algorithms would perform best on the upcoming requests, can we combine the algorithms in some generic way to obtain a competitive online strategy? This has been a long-standing question in the community of online algorithms [START_REF] Azar | On-line choice of on-line algorithms[END_REF][START_REF] Blum | On-line learning and the metrical task system problem[END_REF]. To find an answer, it is a crucial to understand to what extent such an online strategy can benefit from the input of multiple algorithms and what is a suitable benchmark to evaluate its performance.

While in a completely general setting such an online strategy and a corresponding benchmark may not exist, in our paper we propose an algorithm for online linear problems with covering constraints that is competitive with a new benchmark (informally the best linear combination of the experts). Therefore, our paper partially addresses the question we raised in the previous paragraph.

Model and Problem

Covering problem with experts. We have n resources and each resource i has a cost per unit c i that we know in advance (1 ≤ i ≤ n). Let x i be a non-negative variable representing the amount chosen from resource i. The total cost of a solution

(x i ) n i=1 is n i=1 c i x i .
The problem includes K experts and the problem's (covering type) constraints are revealed online (one by one). At each time t ≥ 1, we receive a covering constraint n i=1 a t i x i ≥ 1 (where a t i ≥ 0) and each expert k (where 1 ≤ k ≤ K) provides a solution (s t i,k ) n i=1 . An algorithm can observe the experts' solutions and afterwards it must update its own solution (denoted as (x t i ) n i=1 ) to satisfy the new constraint, while maintaining the satisfaction of the previous ones. This algorithm must update its solution in the sense of online algorithms, so it cannot modify the previously made decisions. Formally,

x t i ≥ x t-1 i ∀ i, t.
Our goal is to design such an algorithm and minimize n i=1 c i x T i subject to all online covering constraints t, where 1 ≤ t ≤ T . The value T is the last time a constraint is released, and it is not known by the algorithm.

Experts. In our model, the experts' predictions are also online solutions. In other words, the experts' solutions fulfill the following properties:

1. for every expert k and for every time t the solution (s t i,k ) n i=1 is feasible, therefore, every constraint t where 1 ≤ t ≤ t is satisfied; 2. for every expert k and for every time t and for every resource i, the previous expert solutions are irrevocable, therefore s t i,k ≥ s t i,k for all t ≤ t.

These properties can be verified online. If some experts do not satisfy them, we simply ignore those experts both in the decision-making and in the benchmark. A crucial remark: we do not assume that the experts' solutions must be tight at each constraint t, meaning that n i=1 a t i s t i,k = 1 ∀t, k. This assumption is unrealistic and cannot be maintained in an online manner (see the discussion in Appendix A). Besides, assuming tight constraint satisfaction would simplify the problem, while intuitively, the difficulty of designing competitive algorithms comes from the lack of obvious ways to distinguish good expert solutions from (probably many) non-efficient/misleading ones.

min n i=1 c i x T i = min n i=1 c i T t=1 x t i -x t-1 i subject to K k=1 w t k = 1 ∀ t x t i ≥ K k=1 w t k s t i,k ∀ i, t x t i ≥ x t-1 i ∀ i, t w t k ≥ 0 ∀ t, k
where 1 ≤ t ≤ T and 1 ≤ i ≤ n. Benchmark. We consider a dynamic benchmark that intuitively captures the best linear combination of all experts' solutions over time. Informally, at any online time step, the benchmark can take a linear combination of the experts' solutions. The linear combination can be changed over time, and it can be different from previous combinations. However, the benchmark's decisions are also online, so it cannot decrease the value of the decision variables (x i ). We refer to our benchmark with the name LIN-COMB from now on. The LIN-COMB benchmark's formal description is a linear program, visible on Figure 1. Let w t k ≥ 0 be the weight assigned by the LIN-COMB benchmark to expert k (where 1 ≤ k ≤ K) at time t. Since we consider a linear combination, the constraint K k=1 w t k = 1 must hold. The solution of LIN-COMB at time t is ideally x t i = K k=1 w t k s t i,k , however, x t i must be larger than x t-1 i . Therefore, we set

x t i = max K k=1 w t k s t i,k , x t-1 i
. In other words, given the chosen weights, if

K k=1 w t k s t i,k < x t-1 i then x t i ← x t-1 i , otherwise x t i ← K k=1 w t k s t i,k .
Since every expert's solution is feasible by our assumptions, at each time t and for all resource i (where 1 ≤ i ≤ n), the constructed solution x t i ≥ K k=1 w t k s t i,k constitutes a feasible solution to the covering constraints of the original covering problem. Formally, for every constraint t with t ≤ t, n i=1

a t i x t i ≥ n i=1 a t i K k=1 w t k s t i,k = K k=1 w t k n i=1 a t i s t i,k ≥ K k=1 w t k ≥ 1
where the second inequality holds due to the feasibility of the experts' solutions. We highlight that the best-expert benchmark is included in LIN-COMB. By setting w t k * = 1 for all t, where 1 ≤ t ≤ T , and w t k = 0 for all k = k * where k * we get the best expert in hindsight (so x t i = s t i,k * for all i, t).

Our approach and contribution

To design competitive algorithms with the new benchmark, we consider a primal-dual approach. First, we relax the linear program formulation of LIN-COMB (visible on Figure 1), which serves as a lower bound. Then, we take the dual of the relaxation, which is a lower bound on the relaxation. Therefore, following the chain of lower bounds, the dual problem is a lower bound on the LIN-COMB benchmark.

At every time step during the execution, our algorithm constructs decisions based on the solution of a convex program. Our approach is inspired by the convex regularization method of [START_REF] Buchbinder | Competitive analysis via regularization[END_REF]. The objective of the convex program is a shifted entropy function. These functions have been widely used, in particular in the recent breakthrough related to k-server [START_REF] Bubeck | K-server via multiscale entropic regularization[END_REF][START_REF] Buchbinder | k-servers with a smile: Online algorithms via projections[END_REF] and metrical tasks problems [START_REF] Bubeck | Metrical task systems on trees via mirror descent and unfair gluing[END_REF], in which the entropy functions are shifted by constant parameters. A novel point in our approach is that the entropy function is shifted by the average of the experts' solutions. Moreover, regarding the constraints of the convex program, instead of using the experts' solutions directly, we define auxiliary solutions that guarantee tight constraint satisfaction and use them in the constraints. Intuitively, this eliminates/modifies the malicious experts' solutions.

Let ρ be the maximum ratio between the experts' solutions on the resources. Formally,

ρ := max i max t ,t K k=1 s t i,k K k=1 s t i,k s.t. K k=1 s t i,k > 0.
Informally, ρ represents the discrepancy across the experts' predictions. Our main result is an algorithm that has an objective cost at most O(ln(Kρ)) times the cost of the LIN-COMB benchmark.

In particular, for 0-1 optimization problems, where the experts provide integer (deterministic or randomized) solutions, our algorithm is O(ln K)-competitive with LIN-COMB. An interesting feature of our algorithm is its resilience to the fluctuation of the quality of predictions (as discussed in the section below and illustrated in the experiments). Much of the research focusing on surpassing worst-case performance guarantees is motivated by the spectacular advances of machine learning (ML). Specifically, ML methods can detect patterns among the arriving input requests and provide valuable insights for the online algorithms regarding future requests. [START_REF] Lykouris | Competitive caching with machine learned advice[END_REF] introduced a general framework to integrate ML predictions into classical algorithm designs to surpass the worst-case performance limit. As a result, many practically relevant online problems were revisited to enhance existing classical algorithms with ML predictions (see the aforementioned [START_REF] Lattanzi | Online scheduling via learned weights[END_REF][START_REF] Mitzenmacher | Scheduling with predictions and the price of misprediction[END_REF][START_REF] Lykouris | Competitive caching with machine learned advice[END_REF][START_REF] Rohatgi | Near-optimal bounds for online caching with machine learned advice[END_REF][START_REF] Antoniadis | Online metric algorithms with untrusted predictions[END_REF][START_REF] Gollapudi | Online algorithms for rent-or-buy with expert advice[END_REF][START_REF] Kumar | Improving online algorithms via ML predictions[END_REF][START_REF] Angelopoulos | Online Computation with Untrusted Advice[END_REF][START_REF] Hsu | Learning-based frequency estimation algorithms[END_REF][START_REF] Kraska | The case for learned index structures[END_REF][START_REF] Mitzenmacher | A model for learned bloom filters, and optimizing by sandwiching[END_REF][START_REF] Antoniadis | Mixing predictions for online metric algorithms[END_REF]).

Related work and discussions

On a high-level view, we aim to design algorithms that are robust (competitive) to the offline optimal solution and also consistent with the expert's predictions. Ideally, the performance of the designed algorithm should surpass previous bounds whenever the predictions are reliable (low errors). However, most learning-augmented algorithms suffer when the error rates are neither very low nor very high, resulting in prediction confidence that is neither very low nor very high. Figure 2 provides a general picture of the performance of an algorithm with predictions, which is representative for many problems (for example, [START_REF] Bamas | The primal-dual method for learning augmented algorithms[END_REF][START_REF] Kevi | Primal-dual algorithms with predictions for online bounded allocation and ad-auctions problems[END_REF]). In the figure, η indicates the confidence in the predictions (or equivalently the error rate of predictions). The learning-augmented algorithm's performance bound is the maximum value of the green and orange curves (gray shaded area on the figure). We can observe that when 0.4 ≤ η ≤ 0.9, the algorithm's performance guarantee is worse than the classical worst-case guarantee (that can be achieved by simply ignoring all predictions). Intuitively, in the case of neither very low nor very high confidence in the predictions, the algorithm has a hard time deciding if it should follow the predictions or the best-known standard algorithm in the worst-case paradigm. It naturally raises the question of whether one can surely guarantee to achieve at least a constant factor of the worst-case guarantee (where the constant is as close to 1 as possible), assuring the resilience of the output solutions despite the quality of the predictions. Our algorithm, together with the new benchmark, provides an answer to this question.

The paper of [START_REF] Anand | Online algorithms with multiple predictions[END_REF] is closely related to ours and studies the design of algorithms with multiple experts. They consider a DYNAMIC benchmark that is intuitively the minimum cost solution that is supported by at least one expert solution at each step. Formally:

DYNAMIC = min x∈ X n i=1 c i xi , where X = {x : ∀ i ∈ [n], ∀ t ∈ [T ], ∃ k ∈ [K] such that s t i,k ≤ xi } Our benchmark, LIN-COMB, is included in DYNAMIC, since every solution x t
i in LIN-COMB satisfies:

x t i ≥ k s t i,k w t k ≥ min k {s t i,k }
therefore, for any i and t, there exists k such that x t i ≥ s t i,k . However, the inverse is not true: a solution xt ∈ X in DYNAMIC is not necessarily a linear combination of the experts' solutions. The DYNAMIC benchmark in [START_REF] Anand | Online algorithms with multiple predictions[END_REF] relied on the assumption that at every time step the experts' solutions are tight. This assumption is unrealistic and impossible to maintain in online solutions (see Appendix A). [START_REF] Anand | Online algorithms with multiple predictions[END_REF] claimed an O(log K)-competitive algorithm in the DYNAMIC benchmark. Unfortunately, this is incorrect; we show an example in Appendix B in which their algorithm's performance guarantee is unbounded in the DYNAMIC benchmark.

Integrating multiple predictions into the online algorithm design was a topic of other papers as well. As an example, [START_REF] Gollapudi | Online algorithms for rent-or-buy with expert advice[END_REF] studied the ski rental problem with multiple predictions. The authors defined a consistency metric, which compares the performance of their algorithm to the optimal solution, given that at least one prediction (among the k predictions) is optimal. [1] also considered multiple predictions in the online facility location problem. They compared the performance of their algorithm to the best possible solution obtained on the union of the suggestions. Recently, [START_REF] Dinitz | Algorithms with prediction portfolios[END_REF] studied the use of multiple predictors for several problems such as matching, load balancing, and non-clairvoyant scheduling. They provided algorithms competitive to the best predictor for such problems. An important remark: all the above benchmarks are captured within LIN-COMB.

Furthermore, [START_REF] Antoniadis | Mixing predictions for online metric algorithms[END_REF] proposed an algorithm with multiple experts for the metrical task system problem. Their benchmark allows switching from one expert to another at each time step, but it does not allow combinations of experts or any solution not suggested by one of the experts. In our LIN-COMB benchmark, the linear combinations that evolve over time could result in a solution that is not suggested by one of the experts and potentially they can be much more efficient. In [START_REF] Antoniadis | Mixing predictions for online metric algorithms[END_REF] there is a cost for state transitions, which is appropriate for their problems, but in many other problems, the smooth transition with additional costs from previous decisions to new ones is not allowed (past decisions are immutable). Therefore, the results of [START_REF] Antoniadis | Mixing predictions for online metric algorithms[END_REF] are not applicable to our setting.

Combining online algorithms into a new algorithm to achieve better results than the individual input algorithms has been a long-standing online algorithm design question [START_REF] Azar | On-line choice of on-line algorithms[END_REF][START_REF] Blum | On-line learning and the metrical task system problem[END_REF]. Its intrinsic difficulty is similar to the issue we mentioned earlier: when the performance of the given input algorithms (or heuristics) is unclear (especially in the online setting), it is challenging to create a combination that can surpass the performance of the included algorithms. Following the current development of online algorithm design techniques with multiple predictions, this subject has been renewed with different machine learning approaches. Our paper contributes to this line of research.

Online covering with multiple experts

Our proposed algorithm solves online covering problems by creating linear combinations of the solutions proposed by K experts in an online manner. Recall that we evaluate the performance of our algorithm with the LIN-COMB benchmark (formalized on Figure 1), which consists of the best linear combination of the experts' solution at each step.

Since our LIN-COMB benchmark is a linear combination of the experts' solutions, the equality K k=1 w t k = 1 must hold, where w t k ≥ 0 is the weight assigned to expert k (where 1 ≤ k ≤ K) at time t. In the following, we formulate a relaxed version of the LIN-COMB formulation, where K k=1 w t k ≥ 1. Additionally, the relaxed formulation enables us to avoid the (online) hard constraint requiring w t k s t i,k ≥ w t-1 k s t-1 i,k to hold, and instead, we introduce a new variable, y t i , to represent the increase of x t i compared to x t-1 i . When w t k s t i,k < w t-1 k s t-1 i,k during the execution, we set the contribution of i at time t to be 0, and therefore, y t i = 0. The relaxed formulation is visible on Figure 3. Due to the relaxed constraint, the optimal solution of the relaxed linear program is a lower bound of our LIN-COMB benchmark. The dual of the relaxation is displayed on Figure 4. According to the theorem of weak duality, any feasible solution of the dual program lower bounds any feasible solution of the primal program, and therefore, any feasible dual solution also lower bounds our LIN-COMB benchmark. Following the chain of lower bounds, our approach to design a competitive algorithm is as follows. At every time step t, we build solutions for all x t i together with the solutions for the dual problem (α t , β t i ). Then, we bound the cost of the algorithm to that of the dual. It is important to emphasize that the designed solution for every x t i must be feasible to the covering constraints, but it may not necessarily be a linear combination of the experts' solutions.

min T t=1 n i=1 c i y t i (α t ) K k=1 w t k ≥ 1 ∀ t (β t i ) K k=1 w t k s t i,k -w t-1 k s t-1 i,k ≤ y t i ∀ i, t w t k , y t i ≥ 0 ∀ i, t, k
(x t k ) α t + n i=1 s t i,k (β t+1 i -β t i ) ≤ 0 ∀ k, t (y t i ) β t i ≤ c i ∀ i, t α t i , β t i ≥ 0 ∀ i, t

Competitive Algorithm

Preprocessing. Recall that by our assumptions, the experts' solutions are always feasible and non-decreasing. At the arrival of the t th constraint, expert k (where 1 ≤ k ≤ K) provides a feasible solution s t k = (s t i,k ) n i=1 , such that s t i,k ≥ s t i,k for all t ≤ t and all i where 1 ≤ i ≤ n. These assumptions do not exclude the possibility for the experts to provide malicious solutions that instruct the algorithm to use an unnecessarily large amount of resources. Note that contrary to the assumption in [START_REF] Anand | Online algorithms with multiple predictions[END_REF], we can not expect the experts' solutions to be always tight. (In Appendix A we show an example that tight solutions cannot be maintained in an online manner.)

To circumvent this issue, we preprocess the experts' solutions at each iteration. During the preprocessing, every solution s t k is scaled down to make it as tight as possible on the t th constraint, while always maintaining s t i,k ≥ s t-1 i,k for all i. Additionally, after the down-scaling, we create an auxiliary solution ŝt k that is tight for the t th constraint. This solution is useful for our algorithm, and we create it with the following procedure.

After the down-scaling, do the following for each expert k.

1. If (s t i,k ) n i=1 is tight on the t th constraint, then set ŝt i,k ← s t i,k for every i.

Let ŝt-1

i,k be the auxiliary solution of expert k at time t -1, meaning that, n i=1 a t- Proof Let us fix an expert k. We prove the lemma by induction. At time step t = 1, one can always scale down the solution s 1 i,k ≥ 0 such that the first constraint becomes tight. Assume that the lemma holds until t -1, n i=1 a t-1 i ŝt-1 i,k = 1 and ŝt-1 i,k ≤ s t-1 i,k . Consider time t. If after scaling down (at the first step in the procedure) the t th constraint becomes tight, then we are done. Otherwise, we have

1 i ŝt-1 i,k = 1. Given I := {i : s t i,k > ŝt-1 i,k • a t-1 i a t i }, we set ŝt i,k ← s t i,k if i / ∈ I
1 < n i=1 a t i s t i,k = i∈I a t i s t i,k + i / ∈I a t i s t i,k , 1 = n i=1 a t-1 i ŝt-1 i,k = n i=1 a t i ŝt-1 i,k • a t-1 i a t i ≥ i∈I a t i ŝt-1 i,k • a t-1 i a t i + i / ∈I a t i s t i,k
Hence, there exists ŝt

i,k ∈ ŝt-1 i,k • a t-1 i a t i , s t i,k for every i, where 1 ≤ i ≤ n, such that n i=1 a t i ŝt i,k = 1.
Algorithm. At the arrival of the t th constraint, 1. solve the following convex program and set w t to be the obtained optimal solution

min w n i=1 c i K k=1 s t i,k w i,k + δ t i ln K k=1 s t i,k w i,k + δ t i K k=1 s t-1 ik w t-1 i,k + δ t-1 i - K k=1 s t i,k w i,k (γ t ) n i=1 a t i K k=1 ŝt i,k w i,k ≥ 1 ∀ t (λ t i ) K k=1 w i,k ≥ 1 ∀ i (µ t i ) K k=1 s t i,k w i,k ≥ 0 ∀ i, t
where

δ t i = 1 K k s t i,k .
Note that in this program, we use the auxiliary solution ŝt i,k in the first constraint. For every i where s t i,k = 0 for all k, the term related to i is not included in the objective function of the convex program. (We can set w i,k = 0 for all k beforehand.) 2. For all

i if K k=1 w t i,k s t i,k > x t-1 i then set x t i ← K k=1 w t i,k s t i,k ; otherwise set x t i ← x t-1 i . Note:
To avoid the possible division by 0 in the denominator of the objective function's logarithm, we can use a dummy expert, who sets each variable to some small value and then follows the greedy heuristic to solve the problem at each arriving constraint. The presence of this expert only changes the competitive ratio to O(logK + 1). Additionally, upon the arrival of the first constraint, we treat the denominator as 1.

Analysis

As w t is the optimal solution of the convex program and (γ t , λ t i , µ t i ) is the optimal solution of its dual, the following Karush-Kuhn-Tucker (KKT) and complementary slackness conditions hold.

n i=1 a t i k ŝt i,k w t i,k -1 γ t = 0 ∀t K k=1 w t i,k -1 λ t i = 0 ∀i, t K k=1 s t i,k w t i,k µ t i = 0 ∀i, t c i s t ik ln K k=1 s t i,k w t i,k + δ t i K k=1 s t-1 ik w t-1 i,k + δ t-1 i -a t i ŝt i,k γ t -λ t i -s t i,k µ t i = 0 ∀i, k, t γ t , λ t i , µ t i ≥ 0 ∀i, t Moreover, if K k=1 w t i,k s t i,k > 0, meaning that µ t i = 0, then c i s t ik ln K k=1 s t i,k w t i,k + δ t i K k=1 s t-1 ik w t-1 i,k + δ t-1 i -a t i ŝt i,k γ t -λ t i = 0 (1)
Dual variables and feasibility. We set the dual variables of the linear program relaxation of our LIN-COMB benchmark based on the dual variables of the convex program used inside the algorithm.

α t = 1 ln(Kρ) γ t + i λ t i , β t i = 1 ln(Kρ) c i ln (1 + 1/K) • max t K k=1 s t i,k K k=1 s t-1 i,k w t-1 i,k + δ t-1 i
where recall that ρ = max i,t ,t

K k=1 s t i,k K k=1 s t i,k : K k=1 s t i,k > 0 .
Lemma 2 The x t i solutions set by the algorithm for the original covering problem and the dual variables (α t , β t i ) of the LIN-COMB benchmark's linear program relaxation are feasible.

Proof We first prove that the x t i variables satisfy the covering constraints by induction. At time 0, no constraint has been released yet, and every variable is set to 0. This all-zero solution is feasible. Let us assume that the algorithm provides feasible solutions up to time t -1. At time t, the algorithm maintains the inequality x t i ≥ x t-1 i , so all constraints t where t < t are satisfied. Besides, x t i is always at least k w t i,k s t i,k , which is larger than k w t i,k ŝt i,k since s t i,k ≥ ŝt i,k for all i, k by the preprocessing step. Hence, the constraint t is also satisfied, formally,

n i=1 a t i x t i ≥ n i=1 a t i k ŝt i,k w t i,k ≥ 1.
In the remaining part of the proof, we show the feasibility of α t and every β t i . Since γ t ≥ 0 and λ t i ≥ 0 for all i and t, we get that α t ≥ 0. In the definition of β t i , the nominator of the logarithm term is always larger than the denominator, and it is smaller than Kρ times the denominator. Consequently, 0 ≤ β t i ≤ c i . Furthermore,

β t+1 i -β t i = - 1 ln(Kρ) c i ln K k=1 s t i,k w t i,k + δ t i K k=1 s t-1 i,k w t-1 i,k + δ t-1 i .
Since i a t i ŝt i,k = 1, using the KKT conditions, we get:

α t + n i=1 s t ik β t+1 i -β t i = 1 ln(Kρ) γ t + i λ t i - 1 ln(Kρ) n i=1 s t i,k c i ln K k=1 s t ik w t i,k + δ t i K k=1 s t-1 ik w t-1 i,k + δ t-1 i = 1 ln(Kρ) γ t + n i=1 λ t i - n i=1 a t i ŝt i,k γ t + λ t i + s t i,k µ t i ≤ 0
Theorem 1 The algorithm's cost is at most O(ln(Kρ))-competitive in the LIN-COMB benchmark.

Proof Lemma 2 proved that our algorithm creates feasible solutions for the dual problem of the LIN-COMB benchmark relaxation and for the original covering problem. We show that the algorithm's solution increases the primal objective value of the original covering problem by at most O(ln(Kρ)) times the value of the dual solution, which serves as the lower bound on the LIN-COMB benchmark -the best linear combination of the experts' solutions.

n i=1 c i (x t i -x t-1 i ) = i:x t i >x t-1 i c i (x t i -x t-1 i ) ≤ i:x t i >x t-1 i c i (x t i + δ t i ) ln x t-1 i + δ t i x t-1 i + δ t i (2)
≤ i:x t i >x t-1 i c i (x t i + δ t i ) ln x t-1 i + δ t i x t-1 i + δ t-1 i (3)
= i:x t i >x t-1 i c i K k=1 s t i,k w t i,k + 1 K K k=1 s t i,k ln K k=1 s t i,k w t i,k + δ t i x t-1 i + δ t-1 i (4)
≤ i:x t i >x t-1 i c i K k=1 s t i,k w t i,k + 1 K K k=1 s t i,k ln K k=1 s t i,k w t i,k + δ t i K k=1 s t-1 i,k w t-1 i,k + δ t-1 i (5)
= i:x t i >x t-1 i K k=1 (w t i,k + 1/K)c i s t i,k ln K k=1 s t i,k w t i,k + δ t i K k=1 s t-1 i,k w t-1 i,k + δ t-1 i = i:x t i >x t-1 i K k=1 (w t i,k + 1/K) a t i ŝt i,k γ t + λ t i (6)
≤ n i=1 K k=1 (w t i,k + 1/K) a t i ŝt i,k γ t + λ t i = n i=1 a t i K k=1 w t i,k ŝt i,k γ t + n i=1 K k=1 w t i,k λ t i + 1 K K k=1 n i=1 a t i ŝt i,k γ t + 1 K K k=1 n i=1 λ t i = 2γ t + 2 n i=1 λ t i = ln(Kρ)α t (7)
The above corresponding transformations hold since:

(2) follows from the inequality a -b ≤ a ln(a/b) for all 0 < b ≤ a;

(3) holds since

δ t i ≥ δ t-1 i (because s t i,k ≥ s t-1 i,k for all i, k, t); (4) is valid because x t i > x t-1 i , so x t i = K k=1 s t i,k w t i,k ; (5)
is by the design of the algorithm:

x t-1 i ≥ K k=1 s t-1 i,k w t-1 i,k ; (6) since given that x t i > x t-1 i ≥ 0 (so K k=1 s t i,k w t i,k = x t i > 0)
, the KKT condition (1) applies; [START_REF] Bamas | The primal-dual method for learning augmented algorithms[END_REF] is true due to the complementary slackness conditions and that n i=1 a t i ŝt i,k = 1.

Corollary 1 For 0-1 optimization problems in which experts provide integer (deterministic or randomized) solutions, the algorithm is O(ln K)-competitive in the LIN-COMB benchmark. Subsequently, there exists an algorithm such that its performance is O(ln K)-competitive in the LIN-COMB benchmark and is up to a constant factor to the best guarantee in the worst-case benchmark Proof

: K k=1 s t i,k > ≤ K 1
Therefore, the competitive ratio of the main algorithm in the LIN-COMB benchmark is O(log Kρ) = O(log K 2 ).

To obtain an algorithm that is competitive in both the LIN-COMB and the worst-case benchmarks, we proceed as follows (an illustration in Figure 5). We first apply the main algorithm on the K experts' predictions to obtain an online algorithm, named A. Algorithm A is O(ln K)competitive in the LIN-COMB benchmark. Let B be the algorithm with the best worst-case guarantee. One applies the main algorithm one more on two algorithms, A and B. The final algorithm is O(ln 2)-competitive to both A and B. In other words, its performance is O(ln K)competitive in the LIN-COMB benchmark and is up to a constant factor worse than the best guarantee in the worst-case benchmark.

By Corollary 1, given a 0-1 optimization problem, if there are K deterministic online algorithms, then we can design an algorithm that has a cost at most O(log K) times that of the best linear combination of those algorithms at any time. Similarly, if K given online algorithms are randomized (they output 0-1 solutions with probabilities), then our algorithm has an expected cost (randomization over the product of the distributions of those solutions) at most O(log K) times that of the best linear combination of those algorithms at any time. Many practical problems admit 0-1 solutions, for which our algorithm is of interest. Consider problems like network design, ski rental, TCP acknowledgement, facility location, etc. Given the fractional solutions constructed by our algorithm, we can apply existing online rounding schemes to obtain integral solutions for such problems.

Experiments

Implementation. The first step of our proposed algorithm is to solve a convex program. In the experiments, we approximate the optimal solution of this program using a vanilla Frank-Wolfe implementation. The linear minimization step within Frank-Wolfe is solved with the Gurobi optimizer.

Comparison. The best standard online algorithm for general covering problems without experts is the online multiplicative weight update (MWA) algorithm. In the experiments we compare our algorithm with the MWA algorithm. When a new constraint arrives in the online problem, the MWA algorithm increases each variable x i in the constraint with a rate of

a t i c i (x i + 1/n),
where n is the total number of variables. We also compare our results with the optimum offline solution (that knows the whole instance in advance) and the average solution of the experts.

Input. First, we evaluated the result of our algorithm on the pathological input of the MWA algorithm. This instance includes n variables and n constraints with uniform costs and coefficients. Each arriving constraint in this pathological example includes one less variable. While the optimal solution is 1, the worst-case guarantee of MWA is O(log n). For our algorithm we provided n experts, where (n -1) experts suggest an adversarial trivial solution to set all variables to 1, while 1 expert suggests the optimal offline solution. The result of this experiment is visible on Figure 6. An important highlight: our algorithm managed to identify the good expert among the majority of adversaries, obtaining a better objective value, than MWA. Second, we experimented with the counter example (in Appendix B) to show that the algorithm proposed by [START_REF] Anand | Online algorithms with multiple predictions[END_REF] has an incorrect performance proof. The result is visible on Figure 6. Finally, we generated some instances to observe the performance of our algorithm on non-specific inputs. The specification for the instance generation includes several parameters, which we detail on Figure 7.

Result. Multiplicative weight update is a simple and well-performing algorithm in practice. On its pathological worst-case example, our algorithm performs better, however on most instances the expert suggestions were significantly worse than MWA, which impacted the performance of our algorithm. To some extent, our algorithm can detect the good experts and is robust against even many adversaries. We think that given a real-life problem, it is possible to construct wellperforming experts (for example using past data) and with a fine-tuned convex program solver our algorithm can be of interest for various use-cases.

Worst-case

Conclusion

We introduce a dynamic LIN-COMB benchmark in the setting of multiple expert predictions beyond the traditional static benchmark of the best expert in hindsight and give a competitive algorithm for the online covering problem in this benchmark. Our approach can provide valuable insights into the learning processes related to predictions, in particular, in aggregating information from predictions to improve the performance of existing algorithms, and how to combine online algorithms, an important subject in the online algorithm design community [START_REF] Azar | On-line choice of on-line algorithms[END_REF][START_REF] Blum | On-line learning and the metrical task system problem[END_REF]. The experiments support the fact that our algorithm can differentiate between good and adversarial experts to some extent. An interesting open question is to design competitive algorithms in the LIN-COMB benchmark for different classes of problems, such as packing problems and problems with non-linear objectives.

During the first constraint of every batch, the experts' solutions form an identity matrix. With each disappearing variable in the consecutive constraints, experts who suggested to use variables which are no longer available, choose to set the variable with the smallest index. Consequently, (K -1) experts suggest to use variable x (K-1) and one expert suggests to use x K during the last constraint in the first batch. The pattern of the experts' solutions are identical for each batch. The constraints of the l th batch (1 ≤ l ≤ L) are:

x (l-1)K+1 + x (l-1)K+2 + • • • + x (l-1)K+(K-1) + x lK + x LK+1 ≥ 1

x (l-1)K+2 + • • • + x (l-1)K+(K-1) + x lK + x LK+1 ≥ 1 . . .

x (l-1)K+(K-1) + x lK + x LK+1 ≥ 1

Claim 1 The objective value of Algorithm 1 (from [START_REF] Anand | Online algorithms with multiple predictions[END_REF]) on our example is O(L log(K)) times the DYNAMIC benchmark.

Proof The optimal solution x * of the DYNAMIC benchmark is the solution in which x * LK+1 = 1 and x * i = 0 for i = LK + 1. We verify that x * ∈ X. For each i = lK where 1 ≤ l ≤ L, for each constraint m, x * i ≥ 0 = x i (m, K). For i = lK where 1 ≤ l ≤ L, for each constraint m, x * i ≥ 0 = x i (m, 1) = x i (m, 2) = . . . = x i (m, K -1). Moreover, x * satisfies all constraints (since variable x LK+1 appears in all constraints). Hence, x * ∈ X. Subsequently, the objective value of the DYNAMIC benchmark is 1.

By the design of Algorithm 1, the increasing rate of x LK+1 is zero throughout the execution, and the variables which are not part of the current constraint are not increased. During the first constraint of each batch, the increasing rate of the first K variables in the batch is 1/K, since the increasing rate of variable x i is (x i + 1 K K s=1 x i (j, s)) and initially every variable is set to zero. At the second constraint, the increasing rate of the second variable in the batch is higher than the other variables' increasing rate, because the first expert also uses this variable in its solution. Therefore, the increasing rate of the second variable is (x (l-1)K+2 + 2/K), while the other remaining expert variables in the constraint have an increasing rate of (x i + 1/K). Following the same reasoning (apart from the first constraint in the batch), the variable with the smallest index in the constraint has a higher increasing rate, than the other variables. During the last constraint of each batch, the increasing rate of the last two remaining expert variables are (x (l-1)K+(K-1) + (K -1)/K) and (x lK + 1/K). Keeping the increasing rates and the constraint satisfaction in mind, we can lower

Figure 1 :

 1 Figure 1: Formulation of the LIN-COMB benchmark

Figure 2 :

 2 Figure 2: Robustness-Consistency

Figure 3 :

 3 Figure 3: Formulation of the relaxation of the LIN-COMB benchmark

Figure 4 :

 4 Figure 4: Dual formulation of the relaxation of the LIN-COMB benchmark

Appendix A Counter example for tight online expert solutions

The following example shows that we cannot expect online expert solutions (in the sense of online algorithms) to be tight on the arriving constraints. In the example below, we display the experts' solutions after each constraint.

Expert 2 : 0 2

To have tight a suggestion from Expert 2 on the second constraint, Expert 2 not only has to decrease its value of x 2 (which is not allowed), but even increase the value of x 1 for the first constraint. In other words, Expert 2 has to completely modify its past decisions.

B Counter example for the performance of the algorithm of [START_REF] Anand | Online algorithms with multiple predictions[END_REF] Anand, Ge, Kumar and Panigrahi [START_REF] Anand | Online algorithms with multiple predictions[END_REF] recently proposed online algorithms for online covering problems with multiple expert solutions. We show here a counter example that contradicts Theorem 2.1 presented in Section 3 of their paper. In the proof of Theorem 2.1 the authors state that the total cost of the algorithm is at most 3 times the potential φ at the beginning, i.e., at most O(log K) times the DYNAMIC benchmark. However, in our counter example the total cost of their algorithm is O(L log(K)) times the DYNAMIC benchmark, where L is an arbitrary large number.

B.1 Setting

Algorithm 1 (from [START_REF] Anand | Online algorithms with multiple predictions[END_REF]) receives solutions from K experts. The authors denote with x i (j, s) the solution from expert s for variable i on constraint j. They assume that the expert solutions are tight, formally:

The algorithm's performance is compared to the DYNAMIC benchmark, which is the minimum cost solution that is supported by at least one expert at each step, formally:

where the solution x i (j, s) ≤ xi } While a constraint is not satisfied, their algorithm updates each variable with an increasing rate of

where

is the average of the experts' solutions for x i at the arrival of constraint j. Algorithm 1 of [START_REF] Anand | Online algorithms with multiple predictions[END_REF] scales down the problem with 0.5, so it does not increase any variable above 0.5 and satisfies each constraint with value 0.5. The exact solution is obtained by doubling the variables at the end of the execution. (This descaling is an important aspect in the authors' proof.)

B.2 Counter example

In the following example we reveal in an online manner a linear program parametrized by L with K experts and observe the behavior of Algorithm 1 (from [START_REF] Anand | Online algorithms with multiple predictions[END_REF]).

Objective. The example has (L • K + 1) variables with uniform cost:

Constraints. There are L batches of (K -1) constraints. The first constraint of each batch has (K + 1) variables. The last variable (x LK+1 ) is present in every constraint in every batch, but none of the experts suggests to use this variable. Within a batch, each consecutive constraint has one less variable. The experts set each variable that appears in later batches to 0. The first batch:

bound the value of each variable:

. . .

Summing the terms together, we get that the objective value increases at least with O(log K) during each batch. There are L batches, so the total cost of Algorithm 1 is at least O(L log(K)), while the total cost of the DYNAMIC benchmark is 1, which concludes the proof.

B.3 Comparison

In this specific counter-example, the LIN-COMB benchmark is equivalent to the static best-expert benchmark, i.e., the solution of Expert K . The objective value of LIN-COMB is L (since the optimal solution sets x lK variables for 1 ≤ l ≤ L to one and other variables to 0). In this counterexample, the objective value of our algorithm is O(L log K). Consequently, our proposed algorithm is O(log K) competitive in the LIN-COMB benchmark.