Stochastic k-Server: How Should Uber Work?

TL;DR

This paper develops approximation algorithms for a stochastic variant of the k-server problem, including the Uber problem, providing near-optimal solutions in various metric spaces with applications to correlated request arrivals.

Contribution

It introduces a structural characterization and approximation algorithms for the stochastic k-server problem, extending to the Uber problem and correlated request settings.

Findings

Achieves a 3-approximation for the stochastic k-server problem in line and circle metrics.

Provides an O(log n) approximation in general metrics.

Extends results to correlated request arrivals.

Abstract

In this paper, we study a stochastic variant of the celebrated k-server problem. In the k-server problem, we are required to minimize the total movement of k servers that are serving an online sequence of t requests in a metric. In the stochastic setting we are given t independent distributions <P_1, P_2,..., P_t> in advance, and at every time step i a request is drawn from Pi. Designing the optimal online algorithm in such setting is NP-hard, therefore the emphasis of our work is on designing an approximately optimal online algorithm. We first show a structural characterization for a certain class of non-adaptive online algorithms. We prove that in general metrics, the best of such algorithms has a cost of no worse than three times that of the optimal online algorithm. Next, we present an integer program that finds the optimal algorithm of this class for any arbitrary metric. Finally, by rounding the solution of the linear relaxation of this program, we present an online algorithm for the stochastic k-server problem with the approximation factor of 3 in the line and circle metrics and O(log n) in a general metric of size n. Moreover, we define the Uber problem, in which each demand consists of two endpoints, a source and a destination. We show that given an a-approximation algorithm for the k-server problem, we can obtain an (a+2)-approximation algorithm for the Uber problem. Motivated by the fact that demands are usually highly correlated with the time we study the stochastic Uber problem. Furthermore, we extend our results to the correlated setting where the probability of a request arriving at a certain point depends not only on the time step but also on the previously arrived requests.

Figures

Tables

Table 1. Table 1 : The running time of our algorithm and the optimum algorithm in seconds. For higher number of servers, the optimum solution was not calculable within 5 hours.

Number of Servers	2	3	4	5	6	7	8	9	10	11
Algorithm	6.5	7.6	6.7	7.1	7.5	8.3	8.5	8.4	9.3	8.2
Optimum	0.2	0.8	3.1	8.4	29.4	57.9	126.3	406.7	1477.1	6173.6

Equations

$$\tau (i,A)=\underset{B}{\min }\tau (i-1,B)+E_{r_i\sim P_i}\left[\text{min. distance from B to A subject to serving ri}\right],$$

$${\mathrm{OPT}}_U\ge {\mathrm{OPT}}_k.$$

$${\mathrm{OPT}}_U\ge \sum _{i}d(s_i,t_i).$$

$$C\le \alpha {\mathrm{OPT}}_k+2\sum _{i}d(s_i,t_i)\le (\alpha +2){\mathrm{OPT}}_U.$$

$$d(x,x)=0$$

$$d(x,y)=d(y,x)$$

$$d(x,y)+d(y,z)\ge d(x,z).$$

$$|\mathcal{A}(\mathcal{M},⟨P_1,P_2,\dots ,P_t⟩)|={\mathbb{E}}_{\forall i,r_i\sim P_i}|\mathcal{A}(\mathcal{M},\rho ,⟨P_1,P_2,\dots ,P_t⟩)|.$$

$$|{\mathcal{B}}_{\mathcal{A}}(\mathcal{M},⟨P_1,P_2,\dots ,P_t⟩)|\le 3|\mathcal{A}(\mathcal{M},⟨P_1,P_2,\dots ,P_t⟩)|.$$

$$\sum _{i=1}^{t}d(B_{i-1},B_i)=\sum _{i=1}^{t-1}d(A_{i-1},A_i)\le \sum _{i=1}^{t}d(A_{i-1},A_i)=|\mathcal{A}(\mathcal{M},\rho ,⟨P_1,P_2,\dots ,P_t⟩)|.$$

$$2\sum _{i=1}^{t}d(B_i,r_i)\le 2\sum _{i=1}^{t}d(B_i,A_i)=2\sum _{i=1}^{t}d(A_{i-1},A_i)=2|\mathcal{A}(\mathcal{M},\rho ,⟨P_1,P_2,\dots ,P_t⟩)|.$$

$$|{\mathcal{B}}_{\mathcal{A}}(\mathcal{M},\rho ,⟨P_1,P_2,\dots ,P_t⟩)|\le 3|\mathcal{A}(\mathcal{M},\rho ,⟨P_1,P_2,\dots ,P_t⟩)|.$$

$$|{\mathcal{B}}_{\mathcal{A}}(\mathcal{M},⟨P_1,P_2,\dots ,P_t⟩)|\le 3|\mathcal{A}(\mathcal{M},⟨P_1,P_2,\dots ,P_t⟩)|$$

$$\sum _{\tau }\sum _{u,v}{f}_{\tau ,u,v}d(u,v)+2\sum _{\tau }\sum _v\sum _r{x}_{\tau ,v,r}\mathrm{Pr}(z\sim P_{\tau }=r)d(v,r)$$

$$\forall \tau ,v$$

$$\forall \tau ,u,v$$

$$\forall \tau ,v,r$$

$$\forall \tau$$

$$\forall \tau ,v,r$$

$$\forall \tau ,u,v$$

$$\forall \tau ,v$$

$$\sum _{\tau }\sum _{u,v}{f}_{\tau ,u,v}d(u,v)+2\sum _{\tau }\sum _v\sum _r{x}_{\tau ,v,r}\mathrm{Pr}(z\sim P_{\tau }=r)d(v,r)$$

$$\forall \tau ,v$$

$$\forall \tau ,u,v$$

$$\forall \tau ,v,r$$

$$\forall \tau$$

$$\mathbb{E}|I(A_1)-I(A_2)|=|A_1-A_2|.$$

$$|A_1-A_2|={\int }_0^1|I_{\omega }(A_1)-I_{\omega }(A_2)|d_{\omega }$$

$${\int }_0^1|I_{\omega }(A_1)-I_{\omega }(A_2)|d_{\omega }$$

$$\sum _{u,v\in T;u\in w(v)}Pr(v)|u-v|x_{u,v}$$

$$\forall v\in T\backslash I$$

$$\forall u\in T,i\in l(u)$$

$$\forall u,v\in T,u\in w(v)$$

$$\sum _{u,v\in T;u\in w(v)}Pr(v)|u-v|x_{u,v}$$

$$\forall v\in T\backslash I$$

$$\forall u\in T,i\in l(u)$$

$$\forall u,v\in T,u\in w(v)$$

Full text

Designing the optimal online algorithm in such setting is NP-hard, therefore the emphasis of our work is on designing an approximately optimal online algorithm. We first show a structural characterization for a certain class of non-adaptive online algorithms. We prove that in general metrics, the best of such algorithms has a cost of no worse than three times that of the optimal online algorithm. Next, we present an integer program that finds the optimal algorithm of this class for any arbitrary metric. Finally by rounding the solution of the linear relaxation of this program, we present an online algorithm for the stochastic $k$-server problem with an approximation factor of $3$ in the line and circle metrics and factor of $O(\log n)$ in a general metric of size $n$. In this way, we achieve an approximation factor that is independent of $k$, the number of servers.

Moreover, we define the Uber problem, motivated by extraordinary growth of online network transportation services. In the Uber problem, each demand consists of two points -a source and a destination- in the metric. Serving a demand is to move a server to its source and then to its destination. The objective is again minimizing the total movement of the $k$ given servers. We show that given an $\alpha$-approximation algorithm for the $k$-server problem, we can obtain an $(\alpha+2)$-approximation algorithm for the Uber problem. Motivated by the fact that demands are usually highly correlated with the time (e.g. what day of the week or what time of the day the demand has arrived), we study the stochastic Uber problem. Using our results for stochastic $k$-server we can obtain a 5-approximation algorithm for the stochastic Uber problem in line and circle metrics, and a $O(\log n)$-approximation algorithm for general metrics.

Furthermore, we extend our results to the correlated setting where the probability of a request arriving at a certain point depends not only on the time step but also on the previously arrived requests.

1 Introduction

The $k$-server problem is one of the most fundamental problems in online computation that has been extensively studied in the past decades. In the $k$-server problem we have $k$ mobile servers on a metric space $\mathcal{M}$. We receive an online sequence of $t$ requests where the $i^{th}$ request is a point $r_{i}\in\mathcal{M}$. Upon the arrival of $r_{i}$, we need to move a server to $r_{i}$, at a cost equal to the distance from the current position of the server to $r_{i}$. The goal is to minimize the total cost of serving all requests.

Manasse, McGeoch, and Sleator [31] introduced the $k$-server problem as a natural generalization of several online problems, and a building block for other problems such as the metrical task systems. They considered the adversarial model, in which the online algorithm has no knowledge of the future requests. Following the proposition of Sleator and Tarjan [34], they evaluate the performance of an online algorithm using competitive analysis. In this model, an online algorithm $\operatorname{ALG}$ is compared to an offline optimum algorithm $\operatorname{OPT}$ which is aware of the entire input in advance. For a sequence of requests $\rho$, let $\left|\operatorname{ALG}(\rho)\right|$ and $\left|\operatorname{OPT}(\rho)\right|$ denote the total cost of $\operatorname{ALG}$ and $\operatorname{OPT}$ for serving $\rho$. An algorithm is $c$-competitive if for every $\rho$, $\left|\operatorname{ALG}(\rho)\right|\leq c\left|\operatorname{OPT}(\rho)\right|+c_{0}$ where $c_{0}$ is independent of $\rho$.

Manasse et al. [31] showed a lower bound of $k$ for the competitive ratio of any deterministic algorithm in any metric space with at least $k+1$ points. The celebrated $k$-server conjecture states that this bound is tight for general metrics. For several years the known upper bounds were all exponential in $k$, until a major breakthrough was achieved by Koutsoupias and Papadimitriou [29], who showed that the so-called work function algorithm is $(2k-1)$-competitive. Proving the tight competitive ratio has been the “holy grail” of the field in the past two decades. This challenge has led to the study of the problem in special spaces such as the uniform metric (also known as the paging problem), line, circle, and trees metrics (see [15, 16] and references therein). We also refer the reader to Section 1.3 for a short survey of randomized algorithms, particularly the recent result of Bansal, Buchbinder, Madry, and Naor [7] which achieves the competitive ratio of $O(\log^{3}n\log^{2}k)$ for discrete metrics that comprise $n$ points.

The line metric (or Euclidean 1-dimensional metric space) is of particular interest for developing new ideas. Chrobak, Karloof, Payne, and Vishwnathan [15] were the first to settle the conjecture in the line by designing an elegant $k$-competitive algorithm. Chrobak and Larmore [16] generalized this approach to tree metrics. Later, Bartal and Koutsoupias [10] proved that the work function algorithm is also $k$-competitive in line. Focusing on the special case of $k=2$ in line, Bartal et al. [9] show that, using randomized algorithms, one can break the barrier of lower bound $k$ by giving a $1.98$-competitive algorithm for the case where we only have two servers.

Despite the strong lower bounds for the $k$-server problem, there are heuristics algorithms that are constant competitive in practice. For example, for the paging problem- the special case of uniform metric- the least recently used (LRU) strategy is shown to be experimentally constant competitive (see Section 1.3). In this paper we present an algorithm an run it on real world data to measure its empirical performance. In particular we use the distribution of car accidents obtained from road safety data. Our experiments illustrate our algorithm is performing even better in practice.

The idea of comparing the performance of an online algorithm (with zero-knowledge of the future) to the request-aware offline optimum has led to crisp and clean solutions. However, that is not without its downsides. The results in the online model are often very pessimistic leading to theoretical guarantees that are hardly comparable to experimental results. Indeed, one way to tighten this gap is to use stochastic information about the input data as we describe in this paper.

We should also point out that the competitive analysis is not the only possible or necessarily the most suitable approach for this problem. Since the distributions from which the input is generated are known, one can use dynamic programming (or enumeration of future events) to derive the optimal movement of servers. Unfortunately, finding such an optimal online solution using the distributions is an NP-hard problem 111Reduction from $k$-median to Stochastic $k$-server: to find the $k$ median of set $S$ of vertices, one can construct an instance of stochastic $k$-server with $t=1$ and $P_{1}(v)=1/|S|$ for every $v\in S$. The best initialization of the servers gives the optimum solution to $k$-median of $S$., thus the dynamic programming or any other approach takes exponential time. This raises the question that how well one can perform in comparison to the best online solution. In the rest of the paper we formally define the model and address this question.

A natural and well-motivated generalization of $k$-server is to assume the demands are two points instead of just one, consisting of a source and a destination. To serve a demand we need to move a server to the source and then move it to the destination. We call this problem the Uber problem. One can see, the Uber problem is the same as $k$-server when the sources and the destinations are the same. We also show that, given an $\alpha$-approximation algorithm for the $k$-server problem, we can obtain a $(\alpha+2)$-approximation algorithm for the Uber problem. Thus our results for $k$-server also apply to the Uber problem.

1.1 The Stochastic Model

In this paper, we study the stochastic $k$-server problem where the input is not chosen adversarially, but consists of draws from given probability distributions. This problem has lots of applications such as network transportations and equipment replacement in data centers. The current mega data centers contain hundreds of thousands of servers and switches with limited life-span. For example servers usually retire after at most three years. The only efficient way to scale up the maintenance in data centers is by automation, and robots are designed to handle maintenance tasks such as repairs or manual operations on servers. The replacement process can be modeled as requests that should be satisfied by robots, and robots can be modeled as servers. This problem also has applications in physical networks. As an example, suppose we model a shopping service (e.g. Google Express) as a $k$-server problem in which we receive an online sequence of shopping requests for different stores. We have $k$ shopping cars (i.e., servers) that can serve the requests by traveling to the stores. It is quiet natural to assume that on a certain time of the week/day, the requests arrive from a distribution that can be discovered by analyzing the history. For example, an Uber request is more likely to be from suburb to midtown in the morning, and from midtown to suburb at night. We formalize this stochastic information as follows.

For every $i\in[1\cdots t]$, a discrete probability distribution $P_{i}$ is given in advance from which request $r_{i}$ will be drawn at time step $i$. The distributions are chosen by the adversary and are assumed to be independent but not necessarily identical. This model is inspired by the well-studied model of prophet inequalities 222In the prophet inequality setting, given (not necessarily identical) distributions $P_{1},\ldots,P_{t}$, an online sequence of values $x_{1},\ldots,x_{n}$ where $x_{i}$ is drawn from $P_{i}$, an onlooker has to choose one item from the succession of the values, where $x_{i}$ is revealed at step $i$. The onlooker can choose a value only at the time of arrival. The goal is to maximize the chosen value. [30, 25]. As mentioned before, the case of line metric has proven to be a very interesting restricted case for studying the $k$-server problem. In this paper, we focus mainly on the class of line metric though our results carry over to circle metric and general metrics as well.

In the adversarial model, the competitive ratio seems to be the only well-defined notion for analyzing the performance of online algorithms. However, in the presence of stochastic information, one can derive a much better benchmark that allows us to make fine-grained distinctions between the online algorithms. We recall that in the offline setting, for a class of algorithms $\mathcal{C}$, the natural notion to measure the performance of an algorithm $\operatorname{ALG}\in\mathcal{C}$ is the approximation ratio defined as the worse case ratio of $\left|\operatorname{ALG}\right|$ to $\left|\operatorname{OPT}(\mathcal{C})\right|$ where $\operatorname{OPT}(\mathcal{C})$ is the optimal algorithm in the class. In this paper, we also measure the performance of an online algorithm by its approximation ratio– compared to the optimal online solution. We note that given distributions $P_{1},\ldots,P_{t}$, one can iteratively compute the optimal online solution by solving the following exponential-size dynamic program: for every $i\in[0\cdots t]$ and every possible placement $A$ of $k$ servers (called a configuration) on the metric, let $\tau(i,A)$ denote the minimum expected cost of an online algorithm for serving the first $i$ requests and then moving the servers to configuration $A$. Note that $\tau(i,A)$ can inductively be computed via the following recursive formula

[TABLE]

where $\tau(0,A)$ is initially zero for every $A$.

1.2 Our Results

Our first main result is designing a constant approximation algorithm in the line metric when the distributions for different time steps are not necessarily identical.

Theorem 1.1

There exists a $3$-approximation online algorithm for the stochastic $k$-server problem in the line metric. The running time is polynomial in $k$ and the sum of the sizes of the supports of input distributions. The same guarantee holds for the circle metric.

For the general metric, we present an algorithm with a logarithmic approximation guarantee.

Theorem 1.2

There exists a $O(\log n)$-approximation online algorithm for the stochastic $k$-server problem in a general metric of size $n$.

We prove the theorems using two important structural results. The first key ingredient is a general reduction from class of online algorithms to a restricted class of non-adaptive algorithms while losing only a constant factor in the approximation ratio. Recall that a configuration is a placement of $k$-servers on the metric. We say an algorithm $\operatorname{ALG}$ is non-adaptive if it follows the following procedure: $\operatorname{ALG}$ pre-computes a sequence of configurations $A_{0},A_{1},\ldots,A_{t}$. We start by placing the $k$-servers on $A_{0}$. Upon the arrival of $r_{i}$, (i) we move the servers to configuration $A_{i}$; next (ii) we move the closest server $s$ to $r_{i}$; and finally (iii) we return $s$ to its original position in $A_{i}$. We first prove the following structural result.

Theorem 1.3

For the stochastic $k$-server problem in the general metric, the optimal non-adaptive online algorithm is within $3$-approximation of the optimal online algorithm.

Using the aforementioned reduction, we focus on designing the optimal non-adaptive algorithm. We begin by formulating the problem as an integer program. The second ingredient is to use the relaxation of this program to formalize a natural fractional variant of the problem. In this variant, a configuration is a fractional assignment of server mass to the points of the metric such that the total mass is $k$. To serve a request at point $r_{i}$, we need to move some of the mass to have at least one amount of server mass on $r_{i}$. The cost of moving the server mass is naturally defined as the integral of the movement of infinitesimal pieces of the server mass. By solving the linear relaxation of the integer program, we achieve the optimal fractional non-adaptive algorithm. We finally prove Theorems 1.1 and 1.2 by leveraging the following rounding techniques. The rounding method in line has been also observed by Türkoglu [35]. We provide the proof for the case of line in Section 5 for the sake of completeness. The rounding method for general metrics is via the well-known embedding of a metric into a distribution of well-separated trees while losing a logarithmic factor in the distortion. Bansal et al. [7] use a natural rounding method similar to that of Blum, Burch, and Kalai [12] to show that any fractional $k$-server movement on well-separated trees can be rounded to an integral counterpart by losing only a constant factor.

Theorem 1.4** (first proven in [35])**

Let $\operatorname{ALG}_{f}$ denote a fractional $k$-server algorithm in the line, or circle. One can use $\operatorname{ALG}_{f}$ to derive a randomized integral algorithm $\operatorname{ALG}$ such that for every request sequence $\sigma$, $\operatorname{E}\left[\left|\operatorname{ALG}(\sigma)\right|\right]=\left|\operatorname{ALG}_{f}(\sigma)\right|$. The expectation is over the internal randomness of $\operatorname{ALG}$. Furthermore, in the stochastic model $\operatorname{ALG}$ can be derandomized.

Theorem 1.5** (proven in [7])**

Let $\operatorname{ALG}_{f}$ denote a fractional $k$-server algorithm in any metric. One can use $\operatorname{ALG}_{f}$ to derive a randomized integral algorithm $\operatorname{ALG}$ such that for every request sequence $\sigma$, $\operatorname{E}\left[\left|\operatorname{ALG}(\sigma)\right|\right]\leq O(\log n)\left|\operatorname{ALG}_{f}(\sigma)\right|$.

We further show that in the stochastic setting, if the number of possible input scenarios is $m$, even if the distributions are correlated, one can compute the best fractional online competitive algorithm in time polynomial in $m$ and $n$. Note that since the number of placements of $k$ servers on $n$ points is exponential, it is not possible to enumerate all the possible choices of an online algorithm. We solve this problem by presenting a non-trivial LP relaxation of the problem with size polynomial in $n$ and $m$; therefore obtaining the following result. We present the formal model and analysis in Appendix A.

Theorem 1.6

The optimal online algorithm of the stochastic $k$-server problem with correlated setting in line and circle can be computed in polynomial time w.r.t. the number of possible scenarios. In general metrics, an $O(\log n)$-approximation algorithm can be obtained.

We also show that having an $\alpha$-approximation algorithm for $k$-server, we can obtain a $(\alpha+2)$-approximation for the Uber problem, using a simple reduction.

Theorem 1.7

Let $\operatorname{ALG}$ denote an $\alpha$-approximation algorithm for $k$-server. One can use $\operatorname{ALG}$ to derive a $(\alpha+2)$-approximation algorithm for the Uber problem.

**Proof. **Consider an instance of the Uber problem $I_{U}$. Let $s_{i}$ and $t_{i}$ denote the $i$-th source and destination, respectively. We generate an instance of the $k$-server problem $I_{k}$ by removing every $t_{i}$ from $I_{U}$. In other words the demands are $s_{i}$’s. We use $\operatorname{ALG}$ to provide a solution for $I_{U}$ as follows. For satisfying the $i$-th demand, we use $\operatorname{ALG}$ to move a server to $s_{i}$. Then using the shortest path from $s_{i}$ to $t_{i}$, we move that server to $t_{i}$ and then return it back to $s_{i}$. Let $\operatorname{OPT}_{U}$ and $\operatorname{OPT}_{k}$ denote the cost of the optimal solutions for $I_{U}$ and $I_{k}$, respectively. Let $d(s_{i},t_{i})$ denote the distance of $t_{i}$ from $s_{i}$ in the metric. Let $C$ denote the total movement of the servers. We have,

[TABLE]

$\Box$

1.3 Further Related Work

The randomized algorithms often perform much better in the online paradigm. For the $k$-server problem, a lower bound of $\Omega(\log k)$ is shown by [28] for the competitive ratio of randomized algorithms in most common metrics. Despite the exponential gap, compared to the lower bound of deterministic algorithms, very little is known about the competitiveness of randomized algorithms. In fact, the only known algorithms with competitive ratios below $k$, work either in the uniform metric (also known as the paging problem [21, 32, 2, 8]), a metric comprising $k+1$ points [23], and two servers on the line [9]. Two decades after the introduction of the $k$-server problem, a major breakthrough was achieved by Bansal et al. [7] in discrete metrics with sub-exponential size. If $\mathcal{M}$ comprise $n$ points, their randomized algorithm achieves a competitive ratio of $O(\log^{3}n\log^{2}k)$.

The case of uniform metric has been extensively studied under various stochastic models motivated by the applications in computer caching. Koutsoupias and Papadimitriou [29] consider two refinements of the competitive analysis for server problems. First, they consider the diffuse adversary model. In this model, at every step $i$ the adversary chooses a distribution $D_{i}$ over the uniform metric of the paging problem. Then the $i^{th}$ request is drawn from $D_{i}$ which needs to be served. The distribution $D_{i}$ is not known to the online algorithm and it may depend on the previous requests. However, in their paper, they consider the case wherein it is guaranteed that for every point $p$, $D_{i}(p)\leq\epsilon$ for a small enough $\epsilon$; i.e., the next request is not predictable with absolute certainty for the adversary. The results of Koutsoupias and Papadimitriou and later Young [36] shows that the optimum competitive ratio in this setting is close to $1+\Theta(k\epsilon)$.

The second refinement introduced in [29] restricts the optimal solution to having lookahead at most $\ell$. Hence, one can define a comparative ratio which indicates the worst-case ratio of the cost of the best online solution to the best solution with lookahead $\ell$. They show that for the $k$-server problem, and more generally the metrical task system problem, there are online algorithms that admit a comparative ratio of $2\ell+1$; for some instances this ratio is tight.

Various other models of restricting the adversary (access graph model [14, 26, 22], fault rate model [27, 6, 19], etc) have also been considered for the paging problem (see [33, 11] and references therein for a further survey of these results). Unfortunately, many of the stochastic settings considered for the paging problem do not seem to have a natural generalization beyond the uniform metric setting. For example, in the diffuse adversary model, most of the studied distributions do not weaken the adversary in the general metric. In this paper, we look for polynomial-time approximation algorithms in the class of online algorithms that have access to the distributions.

We would like to mention that various online problems have been previously considered under prophet inequality model or i.i.d. model (where all distributions are identical). The maximum matching problem, scheduling, and online network design has been extensively studied in these models(see e.g. [3, 5, 4, 17, 1, 18]). In the graph connectivity problems, Garg, Gupta, Leonardi,and Sankowski [24] consider the online variants of Steiner tree and several related problems under the i.i.d. stochastic model. In the adversarial model, there exists an $\Omega(\log n)$ lower bound on the competitive ratio of any online algorithm, where $n$ is the number of demands. However, Garg et al. show that under the i.i.d. assumption, these problems admit online algorithms with constant or $O(\log\log n)$ competitive ratios. We refer the reader to the excellent book by Borodin and El-Yaniv [13] for further study of online problems.

2 Preliminaries

In this section we formally define the stochastic $k$-server problem. The classical $k$-server problem is defined on a metric $\mathcal{M}$ which consists of points that could be infinitely many. For every two points $x$ and $y$ in metric $\mathcal{M}$, let $d(x,y)$ denote the distance of $x$ from $y$ which is a symmetric function and satisfies the triangle inequality. More precisely for every three points $x$, $y$, and $z$ we have

[TABLE]

In the $k$-server problem the goal is to place $k$ servers on $k$ points of the metric, and move these servers to satisfy the requests. We refer to every placement of the servers on the metric points by a configuration. Let $\rho=\langle r_{1},r_{2},\ldots,r_{t}\rangle$ be a sequence of requests, the goal of the $k$-server problem is to find configurations $\langle A_{0},A_{1},A_{2},\ldots,A_{t}\rangle$ such that for every $i$ there exists a server on point $r_{i}$ in configuration $A_{i}$. We say such a list of configurations is valid for the given list of requests. A valid sequence of configurations is optimal if $\sum d(A_{i-1},A_{i})$ is minimized where $d(X,Y)$ stands for the minimum cost of moving servers from configuration $X$ to configuration $Y$. An optimal sequence $\langle A_{0},A_{1},\ldots,A_{t}\rangle$ of configurations is called an optimal offline solution of $\operatorname{OFKS}(\mathcal{M},\rho)$ when $\rho$ is known in advance. We refer to the optimal cost of such movements with $|\operatorname{OFKS}(\mathcal{M},\rho)|=\sum d(A_{i-1},A_{i})$.

We also define the notion of fractional configuration as an assignment of the metric points to non-negative real numbers. More precisely, each number specifies a mass of fractional server on a point. Every fractional solution adheres to the following condition: The total sum of the values assigned to all points is exactly equal to $k$. Analogously, a fractional configuration serves a request $r_{i}$ if there is a mass of size at least 1 of server assigned to point $r_{i}$. An offline fractional solution of the $k$-server problem for a given sequence of requests $\rho$ is defined as a sequence of fractional configurations $\langle A_{0},A_{1},\ldots,A_{t}\rangle$ such that $A_{i}$ serves $r_{i}$.

In the online $k$-server problem, however, we are not given the whole sequence of requests in the beginning, but we will be informed of every request once its realization is drawn. An algorithm $\mathcal{A}$ is an online algorithm for the $k$-server problem if it reports a configuration $A_{0}$ as an initial configuration and upon realization of every request $r_{i}$ it returns a configuration $A_{i}$ such that $\langle A_{0},A_{1},\ldots,A_{i}\rangle$ is valid for $\langle r_{1},r_{2},\ldots,r_{i}\rangle$. If $\mathcal{A}$ is deterministic, it generates a unique sequence of configurations for every sequence of requests. Let $\mathcal{A}(\mathcal{M},\rho)$ be the sequence that $\mathcal{A}$ generates for requests in $\rho$ and $|\mathcal{A}(\mathcal{M},\rho)|$ denote its cost.

In the online stochastic $k$-server problem, in addition to metric $\mathcal{M}$, we are also given $t$ independent probability distributions $\langle P_{1},P_{2},\ldots,P_{t}\rangle$ which show the probability that every request $r_{i}$ is realized on a point of the metric at each time. An algorithm $\mathcal{A}$ is an online algorithm for such a setting, if it generates a configuration for every request $r_{i}$ not solely based on $\langle r_{1},r_{2},\ldots,r_{i}\rangle$ and $\langle A_{0},A_{1},\ldots,A_{i-1}\rangle$ but also with respect to the probability distributions. Similarly, we define the cost of an online algorithm $\mathcal{A}$ for a given sequence of requests $\rho$ with $|\mathcal{A}(\mathcal{M},\rho,\langle P_{1},P_{2},\ldots,P_{t}\rangle)|$. We define the expected cost of an algorithm $\mathcal{A}$ on metric $\mathcal{M}$ and with probability distributions $\langle P_{1},P_{2},\ldots,P_{t}\rangle$ by

[TABLE]

For every metric $\mathcal{M}$ and probability distributions $\langle P_{1},P_{2},\ldots,P_{t}\rangle$ we refer to the online algorithm with the minimum expected cost by $\operatorname{OPT}_{\mathcal{M},\langle P_{1},P_{2},\ldots,P_{t}\rangle}$.

An alternative way to represent a solution of the $k$-server problem is as a vector of configurations $\langle B_{0},B_{1},\ldots,B_{t}\rangle$ such that $B_{i}$ does not necessarily serve request $r_{i}$. The cost of such solution is equal to $\sum d(B_{i-1},B_{i})+\sum 2d(B_{i},r_{i})$ where $d(B_{i},r_{i})$ is the minimum distance of a server in configuration $B_{i}$ to request $r_{i}$. The additional cost of $2d(B_{i},r_{i})$ can be thought of as moving a server from $B_{i}$ to serve $r_{i}$ and returning it back to its original position. Thus, every such representation of a solution can be transformed to the other representation. Similarly, $d(B_{i},r_{i})$ for a fractional configuration $B_{i}$ is the minimum cost which is incurred by placing a mass 1 of server at point $r_{i}$. We use letter $B$ for the configurations of such solutions throughout the paper.

In this paper the emphasis is on the stochastic $k$-server problem on the line metric. We define the line metric $\mathcal{L}$ as a metric of points from $-\infty$ to $+\infty$ such that the distance of two points $x$ and $y$ is always equal to $|x-y|$. Moreover, we show that deterministic algorithms are as powerful as randomized algorithms in this setting, therefore we only focus on deterministic algorithms in this paper. Thus, from here on, we omit the term deterministic and every time we use the word algorithm we mean a deterministic algorithm unless otherwise is explicitly mentioned.

3 Structural Characterization

Recall that an online algorithm $\mathcal{A}$ has to fulfill the task of reporting a configuration $A_{i}$ upon arrival of request $r_{i}$ based on $\langle A_{0},A_{1},\ldots,A_{i-1}\rangle$, $\langle r_{1},r_{2},\ldots,r_{i}\rangle$, and $\langle P_{1},P_{2},\ldots,P_{t}\rangle$. We say an algorithm $\mathcal{B}$ is request oblivious, if it reports configuration $B_{i}$ regardless of request $r_{i}$. As such, $\mathcal{B}$ generates configurations $\langle B_{0},B_{1},\ldots,B_{t}\rangle$ for a sequence of requests $\langle r_{1},r_{2},\ldots,r_{t}\rangle$ and the cost of such configuration is $\sum d(B_{i-1},B_{i})+\sum 2d(B_{i},r_{i})$. More precisely, no matter what request $r_{i}$ is, $\mathcal{B}$ will generate the same configuration for a given list of past configurations $\langle B_{0},B_{1},\ldots,B_{i-1}\rangle$, a given sequence of past requests $\langle r_{1},r_{2},\ldots,r_{i-1}\rangle$, and the sequence of probability distributions $\langle P_{1},P_{2},\ldots,P_{t}\rangle$. In the following we show that every online algorithm $\mathcal{A}$ can turn into a request oblivious algorithm $\mathcal{B}_{\mathcal{A}}$ that has a cost of at most $|3\mathcal{A}(\mathcal{M},\rho,\langle P_{1},P_{2},\ldots,P_{t}\rangle)|$ for a given sequence of requests $\rho$.

Lemma 3.1

Let $\mathcal{A}$ be an online algorithm for the stochastic $k$-server problem. For any metric $\mathcal{M}$, there exists a request oblivious algorithm $\mathcal{B}_{\mathcal{A}}$ such that

[TABLE]

**Proof. **Let $\rho$ be a sequence of requests. We define online algorithm $\mathcal{B}_{\mathcal{A}}$ as follows: The configuration that $\mathcal{B}_{\mathcal{A}}$ reports for a given list of input arguments $\langle B_{0},B_{1},\ldots,B_{i}\rangle$, $\langle r_{1},r_{2},\ldots,r_{i}\rangle$, and $\langle P_{1},P_{2},\ldots,P_{t}\rangle$ is the output of algorithm $\mathcal{A}$ on inputs $\langle B_{0},B_{1},\ldots,B_{i}\rangle$, $\langle r_{1},r_{2},\ldots,r_{i-1}\rangle$, and $\langle P_{1},P_{2},\ldots,P_{t}\rangle$ (The same input except that $r_{i}$ is dropped from the sequence of requests). We show the cost of such algorithm for input $\rho$ is at most 3 times the cost of $\mathcal{A}$ for the same input.

Let $\langle A_{0},A_{1},\ldots,A_{t}\rangle$ be the sequence of configurations that $\mathcal{A}$ generates for requests $\rho$ and $\langle B_{0},B_{1},\ldots,B_{t}\rangle$ be the output of algorithm $\mathcal{B}_{A}$. According to the construction of $\mathcal{B}_{\mathcal{A}}$, $B_{0}=A_{0}$ and $B_{i}=A_{i-1}$ for all $1\leq i\leq t$. Note that for algorithm $\mathcal{A}$, we assume every $A_{i}$ serves request $r_{i}$. By definition, the cost of solution $\langle B_{0},B_{1},B_{2},\ldots,B_{t}\rangle$ is equal to $\sum d(B_{i-1},B_{i})+2\sum d(B_{i},r_{i})$. Since $B_{0}=B_{1}=A_{0}$ and $B_{i}$ = $A_{i-1}$,

[TABLE]

Moreover, since every $A_{i}$ servers request $r_{i}$, $d(B_{i},r_{i})\leq d(B_{i},A_{i})=d(A_{i-1},A_{i})$. Hence,

[TABLE]

Inequality (4) along with Equation (5) implies

[TABLE]

Since this holds for all requests $\rho\sim\langle P_{1},P_{2},\ldots,P_{t}\rangle$, we have

[TABLE]

and the proof is complete. $\Box$

An immediate corollary of Lemma 3.1 is that the optimal request oblivious algorithm has a cost of at most $|3\operatorname{OPT}_{\mathcal{M},\langle P_{1},P_{2},\ldots,P_{t}\rangle}(\mathcal{M},\langle P_{1},P_{2},\ldots,P_{t}\rangle)|$. Therefore, if we only focus on the request oblivious algorithms, we only lose a factor of 3 in comparison to the optimal online algorithm. The following lemma states a key structural lemma for an optimal request oblivious algorithm.

Lemma 3.2

For every request oblivious algorithm $\mathcal{B}$, there exists a randomized request oblivious algorithm $\mathcal{B}^{\prime}$ with the same expected cost which is not only oblivious to the last request, but also oblivious to all requests that have come prior to this.

**Proof. **For any given request oblivious online algorithm $\mathcal{B}$, we construct an online algorithm $\mathcal{B}^{\prime}$ which is oblivious to all of the requests as follows: For an input $\langle B_{1},B_{2},\ldots,B_{i-1}\rangle$ of configurations and probability distributions $\langle P_{1},P_{2},\ldots,P_{t}\rangle$, draw a sequence of requests $\langle r_{1},r_{2},\ldots,r_{i}\rangle$ from $\langle P_{1},P_{2},\ldots,P_{t}\rangle$ conditioned on the constraint that $\mathcal{B}$ would generate configurations $\langle B_{1},B_{2},\ldots,B_{i-1}\rangle$ for requests $\langle r_{1},r_{2},\ldots,r_{i-1}\rangle$. Now, report the output of $\mathcal{B}$ for inputs $\langle B_{1},B_{2},\ldots,B_{i-1}\rangle$, $\langle r_{1},r_{2},\ldots,r_{i}\rangle$, and $\langle P_{1},P_{2},\ldots,P_{t}\rangle$.

We define the cost of step $i$ of algorithm $B^{\prime}$ as $d(B_{i-1},B_{i})+2d(B_{i},r_{i})$. Due to the construction of algorithm $\mathcal{B}^{\prime}$, the expected cost of this algorithm at every step $i$ for a random sequence of requests is equal to the expected cost of algorithm $\mathcal{B}$ for a random sequence of requests drawn from $\langle P_{1},P_{2},\ldots,P_{t}\rangle$. Therefore, the expected cost of both algorithms for a random sequence of requests are equal and thus $|\mathcal{B}(\mathcal{M},\langle P_{1},P_{2},\ldots,P_{t}\rangle)|=|\mathcal{B}^{\prime}(\mathcal{M},\langle P_{1},P_{2},\ldots,P_{t}\rangle)|$. $\Box$

Lemma 3.2 states that there always exists an optimal randomized request oblivious online algorithm that returns the configurations regardless of the requests. We call such an algorithm non-adaptive. Since a non-adaptive algorithm is indifferent to the sequence of the requests, we can assume it always generates a sequence of configurations just based on the distributions. For an optimal of such algorithms, all such sequence of configurations should be optimal as well. Therefore, there always exists an optimal non-adaptive online algorithm which is deterministic. By Lemma 3.1 not only do we know the optimal request oblivious algorithm is at most 3-approximation, but also the same holds for the optimal non-adaptive algorithm.

Theorem 3.3

There exists a sequence of configurations $\langle B_{0},B_{1},\ldots,B_{t}\rangle$ such that an online algorithm which starts with $B_{0}$ and always returns configuration $B_{i}$ upon arrival of request $r_{i}$ has an opproximation factor of at most 3.

4 Fractional Solutions

In this section we provide a fractional online algorithm for the $k$-server problem that can be implemented in polynomial time. Note that by Theorem 3.3 we know that there exist configurations $\langle\mathcal{B}_{1},\mathcal{B}_{2},\ldots,\mathcal{B}_{t}\rangle$ such that the expected cost of a non-adaptive algorithm that always returns these configurations is at most 3 times the cost of an optimal online algorithm. Therefore, we write an integer program to find such configurations with the least expected cost. Next, we provide a relaxed LP of the integer program and show that every feasible solution of such LP corresponds to a fractional online algorithm for the stochastic $k$-server problem. Hence, solving such a linear program, that can be done in polynomial time, gives us a fractional online algorithm for the problem.

4.1 Linear Program

Recall that given $t$ independent distributions $\langle P_{1},\ldots,P_{t}\rangle$ for online stochastic $k$-server, an adaptive algorithm can be represented by $t+1$ configurations $\langle B_{0},\ldots,B_{t}\rangle$. Upon the arrival of each request $r_{i}$, we move the servers from configuration $B_{i-1}$ to $B_{i}$ and then one server serves $r_{i}$ and goes back to its position in $B_{i}$. The objective is to find the configurations such that the cost of moving to new configurations in addition to the expected cost of serving the requests is minimized. Therefore the problem can formulated in an offline manner. First we provide an integer program in order to find a vector of configurations with the least cost.

The decision variables of the program represent the configurations, the movement of servers from one configuration to another, and the way that each possible request is served. In particular, at each time step $\tau$:

• •

For each node $v$ there is a variable $b_{\tau,v}\in N$ denoting the number of servers on node $v$.

• •

For each pair of nodes $u$ and $v$, there is a movement variable $f_{\tau,u,v}\in N$ denoting the number of servers going from $u$ to $v$ for the next round.

• •

For each node $v$ and possible request node $r$, there is a variable $x_{\tau,v,r}\in\{0,1\}$ denoting whether $r$ is served by $v$ or not.

In the following integer program, the first set of constraints ensures the number of servers on nodes at each time is updated correctly according to the movement variables. The second set of constraints ensures that each possible request is served by at least one server. The third set of constraints ensures that no possible request is served by an empty node. By the definition, the cost of a sequence of configurations $\langle B_{0},\ldots,B_{t}\rangle$ is $\sum_{i=1}^{t}d(B_{i-1},B_{i})+2\sum_{i=1}^{t}d(B_{i},r_{i})$. Thus the objective is to minimize the expression

[TABLE]

, where $\Pr(z\sim P_{\tau}=r)$ denotes the probability that $r$ is requested at time $\tau$.

[TABLE]

Now we consider the following relaxation of the above integer program.

[TABLE]

5 Reduction from Integral $k$-server to Fractional $k$-server

In this section we show how we can obtain an integral algorithm for the stochastic $k$-server problem from a fractional algorithm. We first show that every fractional algorithm for the line metric can be modified to an integral algorithm with the same cost. Next, we study the problem on HST metrics; we give a rounding method that produces an integral algorithm from a fractional algorithm while losing a constant factor. Finally, we leverage the previously known embedding techniques to show every metric can be embedded into HST’s with a distortion of at most $O(\log n)$. This will lead to a rounding method for obtaining an integral algorithm from every fractional algorithm on general metrics while losing a factor of at most $O(\log n)$. Combining this with the $3$ approximation fractional algorithm that we provide in Section 4, we achieve an $O(\log n)$ approximation algorithm for the stochastic $k$-server problem on general graphs.

5.1 Integrals Are as Strong as Fractionals On the Line

In this section we show every fractional algorithm on the line metric can be derandomized to an integral solution with the same expected cost. The rounding method is as follows: For every fractional configuration $A$, we provide an integral configuration $\operatorname{I}(A)$ such that (i) the distance of two configurations $A_{1}$ and $A_{2}$ is equal to the expected distance of two configurations $\operatorname{I}(A_{1})$ and $\operatorname{I}(A_{2})$. (ii) for every point $x$ in the metric that $A$ has a server mass of size at least $1$ on $x$, there exists a server on point $x$ in $\operatorname{I}(A)$.

Let for every point $x$ in the metric, $A(v)$ denote the amount of server mass on node $v$ of the line. For every fractional configuration $B$, we define a mass function $f_{A}:(0,k]\to V$ as follows. $f_{A}(x)=v_{j}$ if and only if $j$ is the minimum integer such that $\sum_{i=1}^{j-1}A(i)<x$ and $\sum_{i=1}^{j}A(i)\geq x$. Intuitively, if one gathers the server mass by sweeping the line from left to right, $f_{A}(x)$ is the first position on which we have gathered $x$ amount of server mass. The rounding algorithm is as follows:

• •

Pick a random real number $r$ in the interval $[0,1)$.

• •

$\operatorname{I}(A)$ contains $k$ servers on positions $f_{A}(r)$, $f_{A}(r+1)$, $f_{A}(r+2)$, …, $f_{A}(r+k-1)$.

Note that the rounding method uses the same $r$ for all of the configurations. More precisely, we draw $r$ from $[0,1)$ at first and use this number to construct the integral configurations from fractional configurations. The following two lemmas show that both of the properties hold for the rounding algorithm we proposed.

Lemma 5.1

Let $A$ be a fractional configuration and $x$ be a point such that $A(x)\geq 1$. Then $\operatorname{I}(A)$ has a server on $x$.

**Proof. **Due to the construction of our rounding method, for every two consecutive servers $a$ and $b$ in $\operatorname{I}(\mathcal{A})$, the total mass of servers after $a$ and before $b$ in the fractional solution is less than $1$. Therefore, $\operatorname{I}(A)$ should put a server on point $x$, otherwise the total mass of servers in the fractional solution between the first server before $x$ and the first server after $x$ would be at least $1$. $\Box$

The next lemma shows that the rounding preserves the distances between the configurations in expectation.

Lemma 5.2

Let $A_{1}$ and $A_{2}$ be two fractional configurations and $|A_{1}-A_{2}|$ be their distance. The following holds for the distances of the configurations

[TABLE]

**Proof. **The key point behind the proof of this lemma is that the distance of two fractional configurations $A_{1}$ and $A_{2}$ can be formulated as follows

[TABLE]

where $\operatorname{I}_{\omega}(A)$ stands for an integral configurations which places the servers on points $f_{A}(\omega)$, $f_{A}(\omega+1)$, $f_{A}(\omega+2)$, $\ldots$, $f_{A}(\omega+k-1)$. Since at the beginning of the rounding method we draw $r$ uniformly at random, the expected distance of the two rounded configurations is exactly equal to

[TABLE]

which is equal to the distance of $A_{1}$ from $A_{2}$. $\Box$

Theorem 5.3

For any given fractional online algorithm $\mathcal{A}$ for the $k$-server problem on the line metric, there exists an online integral solution for the same problem with the same expected cost.

5.2 Reduction for General Graphs

An HST is a undirected rooted tree in which every leaf represents a point in the metric and the distance of a pair of points in the metric is equal to the distance of the corresponding leaves in the tree. In an HST, weights of the edges are uniquely determined by the depth of the vertices they connect. More precisely, in a $\sigma$-HST the weight of an edges between a vertex $v$ and its children is equal to $\sigma^{h-d_{v}}$ where $h$ stands for the height of the tree and $d_{v}$ denotes the depth of vertex $v$.

Since HSTs are very well structured, designing algorithms on HSTs is relatively easier in comparison to a more complex metric. Therefore, a classic method for alleviating the complexity of the problems is to first embed the metrics into HSTs with a low distortion and then solve the problems on these trees.

Perhaps the most important property of the HSTs is the following:

Observation 5.1

For every pair of leaves $u,v\in T$ of an HST, the distance of $u$ and $v$ is uniquely determined by the depth of their deepest common ancestor.

Note that, the higher the depth of the common ancestor is, the lower the distance of the leaves will be. Therefore, the closest leaves to a leaf $v$ are the ones that share the most common ancestors with $v$. Bansal et al. propose a method for rounding every fractional solution of the $k$-server problem to an integral solution losing at most a constant factor [7].

Theorem 5.4

[7]** Let $T$ be a $\sigma$-HST with $n$ leaves, $\sigma>5$, and let $A=\langle A_{0},A_{1},A_{2},\ldots,A_{t}\rangle$ be a sequence of fractional configurations. There is an online procedure that maintains a sequence of randomized k-server configurations $S=\langle S_{0},S_{1},S_{2},\ldots,S_{t}\rangle$ satisfying the following two properties:

• •

At any time $i$, the state $S_{i}$ is consistent with the fractional state $A_{i}$.

• •

If the fractional state changes from $x_{i-1}$ to $x_{i}$ at time $i$, incurring a movement cost of $c_{i}$, then the state $S_{i-1}$ can be modified to a state $S_{i}$ while incurring a cost of $O(c_{i})$ in expectation.

Embedding general metrics into trees and in particular HSTs has been the subject of many studies. The seminal work of Fakcharoenphol et al. [20] has shown that any metric can be randomly embedded to $\sigma$-HSTs with distortion $O(\frac{\sigma\log n}{\log\sigma})$.

Theorem 5.5

[20]** There exists a probabilistic method to embed an arbitrary metric $\mathcal{M}$ into $\sigma$-HSTs with distortion $\frac{\sigma\log n}{\log\sigma}$.

Therefore, to round a fractional solution on a general metric, we first embed it into $6$-HSTs with a distortion of at most $O(\log n)$ and then round the solution while losing only a constant factor. This will give us an integral algorithm that has an expected cost of at most $O(\log n)$ times the optimal.

Theorem 5.6

For any given fractional online algorithm $\mathcal{A}$ for the $k$-server problem on an arbitrary metric, there exists an online integral solution for the same problem having a cost of no worse that $O(\log n)$ times the cost of $\mathcal{A}$ in expectation.

6 Acknowledgment

We would like to thank Shi Li for having helpful discussions.

Appendix A Correlated Setting

In this section, we study the $k$-server problem when the probability distributions are not independent. Recall that in the independent setting the sequence of requests is referred to by $\rho=\langle r_{1},\ldots,r_{t}\rangle$. In the correlated model we assume all different possibilities for $\rho$ have been given in the form of a set $\mathcal{R}=\{\rho_{1},\ldots,\rho_{m}\}$ of $m$ sequences $\rho_{i}=\langle r_{i,1},\ldots,r_{i,t}\rangle$. Moreover, we assume the probability of each scenario $\rho_{i}$ is denoted by $p_{i}$ and given in advance. Given the list of different scenarios and probabilities, the goal is to design an online algorithm to serve each request $r_{i,j}$ prior to arrival of the next request such that the overall movement of the servers is minimized.

We model this problem by an integer program. We first write an integer program and show that every solution of this program is uniquely mapped to a deterministic online algorithms for the problem. Moreover, every online algorithm can be mapped to a feasible solution of the program. More precisely, each solution of the program is equivalent to an online algorithm of the problem. Furthermore, we show how to derive an online algorithm from the solution of the integer program. These two imply that the optimal deterministic online algorithm can be obtained from the optimal solution of the program.

A.1 Program

To better convey the idea behind the integer program, we first introduce the tree $T$ which is a trie containing all sequences $\rho_{1}$ to $\rho_{m}$. Let us use $w(v)$ to denote the path from the root to a node $v$. With these notations, a node $v\in T$ represents a request which may occur conditioning all requests in $w(v)$ occur beforehand. Besides, every leaf of $T$ uniquely represents one of the $\rho_{i}$’s. Let us use $l(v)$ to denote the set of those indices $i$ for which $\rho_{i}$ is a leaf of the subtree of $v$. At each step $t$, only those $\rho_{i}$’s can be a final option for $R$ that $\langle\rho_{i,1},\ldots,\rho_{i,t}\rangle=\langle r_{1},\ldots,r_{t}\rangle$. Hence, a new request $r_{t}$ can be informative since we know that none of the $\rho_{i}$’s in $l(r_{t-1})\backslash l(r_{t}au)$ will occur anymore. For a node $v$ we define $Pr(v)$ as the probability of all requests in $w(v)$ happening i.e. $Pr(v)=\sum_{i\in l(v)}Pr(R=\rho_{i})$.

We extend the tree $T$ by adding $k-1$ additional nodes. As shown in Figure 1, these nodes form a path leading to the root of $T$. These nodes plus the root represent the initial configuration of the $k$ servers. Let us call these nodes the initial set $I$. Now we can show the movement of the servers in our metric space by means of $k$ tokens in $T$. To do so, we begin with putting one token on each of the $k$ nodes of $I$. Each token corresponds to one of the servers. After a server moves to serve a request $r_{t}$, we move its corresponding token to a node of $T$ which represents the request $r_{t}$. Note that at this step, there is no discrimination between any of the sequences in $l(r_{t})$ in terms of occurrence. This causes a deterministic online algorithm $A$ to serve the first $|w(r_{t})|$ requests of $R$ in the same way if $R$ is going to be one of $\rho_{i}$’s $(i\in l(r_{t}))$. A result of this uniquely serving is that we can use some downward links on $T$ in order to show how each request $v$ gets served. In the next paragraphs we explain about these links and how we construct the integer program.

Let us use $x_{u,v}$ to denote a link from a node $u\in T$ to its descendant $v$. $x_{u,v}$ is one if and only if $A$ uses the same server to serve $u$ and then $v$ without using that server to serve any other request between $u$ and $v$. This consecutive serving may occur with probability $Pr(v)=Pr(u)Pr(v|u)$. In this case, the algorithm moves a server from $u$ to $v$ and pays $|u-v|$ as the distance cost between the two points of the metric space corresponding to $u$ and $v$.

There are two conditions for these links that we must care about. First, since each request $v$ should be served with a server, at least one of the $x_{u,v}$’s should be one for all $u$ in $w(v)$. Without loss of generality, we assume this is exactly one of them, i.e. there is no need to serve a request with more than one server. Second, after serving a request $u$, a server can go for serving at most one other request. That is, for each $i\in l(u)$, there should be at most one $v\in\rho_{i}$ such that $x_{u,v}=1$. This condition guarantees that in serving the sequence of requests $R$, a server which serves $r_{t_{1}}\in R$ has always at most one other request $r_{t_{2}}\in R$ as the next serving request.

The following integer program maintains both conditions for $x_{u,v}$’s and has the expected overall movement of all servers as the objective function:

[TABLE]

Next, we can relax the constraints of the program to make it linear. Therefore, instead of assigning either $\{0\}$ or $\{1\}$, to each $x_{u,v}$ we let it be a real number between 0 and 1. Thus, the integer program turns to the following linear program with the same objective function but more relaxed constraints.

[TABLE]

Note that every feasible solution of the linear program is corresponding to a fractional solution of the problem. Since the optimal solution of the linear program can be found in polynomial time, using the rounding methods presented in Section 5 we obtain an optimal online algorithm for the line metric and a $O(\log n)$ approximation algorithm for general metrics as stated in Theorem 1.6.

Appendix B Experimental Results

The goal of this section is to make an evaluation of our method for the line on a real world data set. The line can be an appropriate model for a plenty of applications. For example, it could be sending road maintenance trucks to different points of a road or sending emergency vehicles to accident scenes along a highway. For this experiment, we take the case of car accidents.

Data sets. We use Road Safety Data333https://data.gov.uk/dataset/road-accidents-safety-data/ to find the distribution of the accidents along the A1444https://en.wikipedia.org/wiki/A1_road_(Great_Britain) road in Great Britain. In 2015, over 1600 accidents occurred on this highway, with an average of 140 accidents per month. We assume a point every 10 miles along the highway. That is 40 points in total. Then we build the distributions with respect to how the accidents are spread over the days of month. In this way, we achieve 30 distributions for 40 points along the line.

Algorithms. We compare the performance of our method to that of the optimum algorithm. To find the optimum solution we use backtracking. The running time of the algorithm is exponential to $k$. However, we use techniques such as branch and bound and exponential dynamic programming to get a fast implementation.

Results. We run different experiments with $k$ from 2 to 11 on the line and distributions explained above. In previous sections we showed an upper bound of 3 for the approximation factor of our algorithm. Interestingly, in these experiments we can observe a better performance as shown by Figure 1. We compare the running time of the algorithms in Table 1. Note that the size of our LP our method solvers does not vary by $k$. This is in fact the reason behind why its running time remains almost the same. In contrast, the running time of the optimum algorithm grows exponentially.