General Framework for Metric Optimization Problems with Delay or with Deadlines

TL;DR

This paper introduces a unified framework for designing and analyzing algorithms for online metric optimization problems involving delays and deadlines, achieving improved competitive ratios across multiple problem variants.

Contribution

The paper presents a general framework that leads to new, improved algorithms for various online metric optimization problems with deadlines or delays, including multilevel aggregation and facility location.

Findings

Deterministic $O(D^{2})$-competitive algorithm for multilevel aggregation on trees.

Randomized $O(rac{ ext{log}^2 n}{n})$-competitive algorithm for service with delay.

Algorithms for facility location with deadlines and delay with competitive ratios of $O( ext{log}^2 n)$.

Abstract

In this paper, we present a framework used to construct and analyze algorithms for online optimization problems with deadlines or with delay over a metric space. Using this framework, we present algorithms for several different problems. We present an $O(D^{2})$-competitive deterministic algorithm for online multilevel aggregation with delay on a tree of depth $D$, an exponential improvement over the $O(D^{4}2^{D})$-competitive algorithm of Bienkowski et al. (ESA '16), where the only previously-known improvement was for the special case of deadlines by Buchbinder et al. (SODA '17). We also present an $O(\log^{2}n)$-competitive randomized algorithm for online service with delay over any general metric space of $n$ points, improving upon the $O(\log^{4}n)$-competitive algorithm by Azar et al. (STOC '17). In addition, we present the problem of online facility location with deadlines. In this problem, requests arrive over time in a metric space, and need to be served until their deadlines by facilities that are opened momentarily for some cost. We also consider the problem of facility location with delay, in which the deadlines are replaced with arbitrary delay functions. For those problems, we present $O(\log^{2}n)$-competitive algorithms, with $n$ the number of points in the metric space. The algorithmic framework we present includes techniques for the design of algorithms as well as techniques for their analysis.

Figures

Equations

$$\mathrm{ALG}={\mathrm{ALG}}^B+{\mathrm{ALG}}^C$$

$$\sum _{u\in T}{\bar{c}}_u=\sum _{j=0}^D{\bar{C}}_j\le \sum _{j=0}^D{\bar{C}}_0=(D+1)kf$$

$$X\le 2\cdot \sum _{l=1}^m\delta (u^{(l-1)},v_q)$$

$$\delta (u^{(l-1)},v_q)$$

$$\ge 2\delta (u^{(l)},v_q)$$

$$X\le 2\cdot \sum _{l=1}^m\frac{1}{2^{l-1}}\cdot \delta (u,v_q)\le 4\delta (u,v_q)$$

$$kf\le \sum _{i=1}^k{\chi }_{{\mu }_i}\le {\omega }_Z$$

$$kf\le {\omega }_Z=\sum _{\sigma \in E_s^{-}}\alpha (\sigma )=\sum _{\mu \in M}c(\mu )\le 2(D+1)\cdot {\mathrm{OPT}}^B+4\cdot {\mathrm{OPT}}^C$$

$$\mathrm{ALG}\le Dkf\le O(D^2)\cdot {\mathrm{OPT}}^B+O(D)\cdot {\mathrm{OPT}}^C$$

$${\delta }_{\mathcal{X}}(x_1,x_2)\le {\mathbb{E}}_{\mathcal{T}\sim \mathcal{D}}\left[{\delta }_{\mathcal{T}}(x_1,x_2)\right]\le O(\log n)$$

$$\mathbb{E}\left[{\mathrm{ALG}}^{\mathcal{X}}\right]$$

$$\le O({\log }^{2}n)\cdot {\mathrm{OPT}}^{\mathcal{X},B}+O({\log }^{2}n)\cdot {\mathrm{OPT}}^{\mathcal{X},C}=O({\log }^{2}n)\cdot {\mathrm{OPT}}^{\mathcal{X}}$$

$$\mathrm{ALG}={\mathrm{ALG}}^B+{\mathrm{ALG}}^C+{\mathrm{ALG}}^D$$

$${\psi }_u(Q)=\left(\sum _{u^{\prime }\in \bar{S}}{\psi }_{u^{\prime }}(Q_1^{u^{\prime }})\right)+f+\sum _{q\in Q_2}\delta (u,v_q)$$

$$d_Q(\hat{t})\ge {\psi }_u(Q)=\left(\sum _{u^{\prime }\in \bar{S}}{\psi }_{u^{\prime }}(Q_1^{u^{\prime }})\right)+f+\sum _{q\in Q_2}\delta (u,v_q)$$

$$d_{\hat{Q}}(\hat{t})=\sum _{u^{\prime }\in \bar{S}}{d}_{{\hat{Q}}_1^{u^{\prime }}}(\hat{t})\le \sum _{u^{\prime }\in \bar{S}}{\psi }_{u^{\prime }}(Q_1^{u^{\prime }})$$

$$d_{Q\backslash \hat{Q}}(\hat{t})=d_Q(\hat{t})-d_{\hat{Q}}(\hat{t})\ge f+\sum _{q\in Q_2}\delta (u,v_q)\ge f$$

$$d_Q(t_i)\ge \left(\sum _{u^{\prime }\in \bar{S}}{\psi }_{u^{\prime }}(Q_1^{u^{\prime }})\right)+f+\sum _{q\in Q_2}\delta (u,v_q)$$

$$d_{\hat{Q}}(t_i)\le \left(\sum _{u^{\prime }\in \bar{S}}{\psi }_{u^{\prime }}(Q_1^{u^{\prime }})\right)$$

$$kf\le \sum _{i=1}^k{\chi }_{{\mu }_i}\le {\omega }_Z$$

$$kf\le {\omega }_Z=\sum _{\sigma \in E_s^{-}}\alpha (\sigma )=\sum _{\mu \in M}c(\mu )\le (D+1)\cdot {\mathrm{OPT}}^B+2\cdot {\mathrm{OPT}}^C+(D+1)\cdot {\mathrm{OPT}}^D$$

$${\omega }_Z=\sum _{\sigma \in E_s^{-}}\alpha (\sigma )=kDw(r)$$

$${\mathrm{ALG}}^B=\sum _{{\text{Explore}}_{\tau }(e)\in V}w(e)\le \sum _{v\in V}{\chi }_v\le {\omega }_Z=kDw(r)$$

$$\sum _{h\in H}{d}_{Q_h}(t)=d_Q(t)\ge w(T_e^Q)-w(e)\ge \sum _{h\in H}w(T_h^{Q_h})$$

$$d_{Q\backslash \hat{Q}}({\tau }_2^{\star })$$

$$\ge w(T_e^{\hat{Q}})-\left(w(T_e^{\hat{Q}})-w(e)\right)=w(e)$$

$$kw(r)\le {\omega }_Z\le {\mathrm{OPT}}^B+D\cdot {\mathrm{OPT}}^D$$

$${\mathrm{ALG}}^D=\sum _{i=1}^m{\mathrm{ALG}}_i^D\le \sum _{i=1}^m{\mathrm{ALG}}_i^B\le {\mathrm{ALG}}^B$$

$${\overline{\mathrm{ALG}}}_i^B$$

$${\overline{\mathrm{ALG}}}_i^B\le 2D^2{\mathrm{OPT}}_i$$

$${\mathrm{ALG}}^B=\sum _{i=1}^m{\overline{\mathrm{ALG}}}_i^B\le 2D^2\cdot \sum _{i=1}^m{\mathrm{OPT}}_i\le 2D^2\cdot \mathrm{OPT}$$

$$\mathrm{ALG}\le 2{\mathrm{ALG}}^B\le 4D^2\cdot \mathrm{OPT}$$

Full text

In addition, we present the problem of online facility location with deadlines. In this problem, requests arrive over time in a metric space, and need to be served until their deadlines by facilities that are opened momentarily for some cost. We also consider the problem of facility location with delay, in which the deadlines are replaced with arbitrary delay functions. For those problems, we present $O(\log^{2}n)$-competitive algorithms, with $n$ the number of points in the metric space.

The algorithmic framework we present includes techniques for the design of algorithms as well as techniques for their analysis.

1 Introduction

Recently in the field of online algorithms, there has been an increasing interest in online problems involving deadlines or delay. In such problems, requests of some form arrive over time, requiring service. In problems with deadlines, each request is equipped with a deadline, by which the request must be served. In problems with delay, this hard constraint is replaced with a more general constraint. In those problems, each request is equipped with a delay function, such that an algorithm accumulates delay cost while the request remains pending. This provides an incentive for the algorithm to serve the request as soon as possible. Deadlines are a special case of delay, as deadlines can be approximated arbitrarily well by delay functions.

The mechanism of adding delay or deadlines can be used to convert a problem over a sequence into a problem over time. For example, a problem in which an arriving request must immediately be served by the algorithm can be converted into a problem with deadlines, providing more flexibility to a possible solution. This conversion often creates interesting problems over time from problems that are trivial over a sequence, as well as enables much better solutions (i.e. lower cost).

A case of special interest is the case of such problems over a metric space. A notable example, which we consider in this paper, is the online multilevel aggregation problem. In this problem, the requests arrive on the leaves of a tree. At any time, the algorithm may choose to transmit any subtree that includes the root of the tree, at a cost which is the sum of the weights of the subtree’s edges. Pending requests on any leaves contained in the transmitted subtree are served by the transmission. The general delay case of this problem was first considered by Bienkowski et al. [7], who gave a $O(D^{4}2^{D})$-competitive algorithm for the problem, with $D$ the depth of the tree. Buchbinder et al. [13] then showed a $O(D)$-competitive deterministic algorithm for the deadline case. In this paper, we improve the result of [7] for general delay exponentially.

Another notable example is the online service with delay problem, presented in [5]. In this problem, requests arrive on points in a metric space, accumulating delay while pending. There is a single server in the metric space, which can be moved from one point to another at a cost which is the distance between the two points. Moving a server to a point at which there exists a pending request serves that request. In [5], an $O(\log^{4}n)$-competitive randomized algorithm is given for the problem, where $n$ is the number of points in the metric space. This algorithm encompasses a random embedding to an hierarchical well-separated tree (HST) of depth $h=O(\log n)$, and an $O(h^{3})$-competitive deterministic algorithm for online service with delay on HSTs. In this paper, we also improve this result to $O(\log^{2}n)$ competitiveness.

In addition, we also present the problem of online facility location with deadlines. In this problem, requests arrive over time on points of a metric space, each equipped with a deadline. The algorithm can open a facility at any point of the metric space, at some fixed cost. Immediately upon opening a facility, the algorithm may connect any number of pending requests to that facility, serving these requests. Connecting a request to a facility incurs a connection cost which is the distance between the location of the request and the location of the facility. In contrast to previous considerations of online facility location, in our problem the facility is only opened momentarily, disappearing immediately after connecting the requests. We also consider the problem of online facility location with delay, in which the deadlines are replaced with arbitrary delay functions. For those problems we present $O(\log^{2}n)$-competitive algorithms, with $n$ the number of points in the metric space.

The problem of facility location is a widely researched classic problem. The modification of ephemeral facilities is highly motivated, as it describes an option of renting facilities instead of buying them. As renting shared resources is a growing trend (e.g. in cloud computing), this problem captures many practical scenarios.

Our paper presents algorithms for online facility location with deadlines, online facility location with delay, online multilevel aggregation with delay and online service with delay. These algorithms all share a common framework that we develop. The framework includes techniques for both the design of the algorithms and their analysis. We believe the flexibility and generality of this framework would enable designing and analyzing algorithms for additional problems with deadlines or with delay.

Our Results

In this paper, we present a framework used to construct and analyze online optimization problems with deadlines or with delay over a metric space. Using this framework, we present the following algorithms.

An $O(D^{2})$-competitive deterministic algorithm for online multilevel aggregation with delay on a tree of depth $D$. This is an exponential improvement over the $O(D^{4}2^{D})$-competitive algorithm in [7]. 2. 2.

An $O(\log^{2}n)$-competitive randomized algorithm for online service with delay over a metric space with $n$ points. This improves upon the $O(\log^{4}n)$-competitive randomized algorithm in [5]. 3. 3.

An $O(\log^{2}n)$-competitive randomized algorithm for online facility location with deadlines over a metric space with $n$ points. 4. 4.

An $O(\log^{2}n)$-competitive randomized algorithm for online facility location with delay over a metric space with $n$ points.

Our algorithms all share a common framework, which we present. The framework provides general structure to both the algorithm and its analysis.

Such an improvement for the online multilevel aggregation problem is only known for the special case of deadlines, as given in [13].

The algorithms for online facility location with deadlines and with delay can be easily extended to the case in which the cost of opening a facility is different for each point in the metric space. This changes the competitiveness of the algorithms to $O(\log^{2}\Delta+\log\Delta\log n)$, where $\Delta$ is the aspect ratio of the metric space.

Our Techniques

All of our algorithms are based on corresponding competitive algorithms for HSTs. The randomized algorithms for general metric spaces are obtained through randomized HST embedding. The $O(D^{2})$-competitive deterministic algorithm for online multilevel aggregation with delay on a tree is based on decomposing the tree into a forest of HSTs. This decomposition is similar to that used in [13] for the case of deadlines.

**The framework – algorithm design. **In designing algorithms for the problems over HSTs, we use a certain framework. In an algorithm designed using the framework, there is a counter for every node (in the case of facility location) or every edge (in the case of online multilevel aggregation and service with delay). The sizes of the counters vary between the problems considered. When the counter for a tree element (either node or edge) is full, the algorithm resets the counter and explores the subtree rooted at that element.

The process of exploration serves some of the pending requests at that subtree, while simultaneously charging counters of descendant tree elements. The exploration takes place in a DFS fashion – if at any time during the exploration of an element the counter of a descendant element is full, the algorithm immediately suspends the exploration of the current element in favor of its descendant. The exploration of the original element resumes only when the exploration of the descendant is complete.

The exploration of specific element has a certain budget, used to charge counters of descendants. This budget is equal to the size of the counter of the element being explored. The algorithm adheres to the budget very strictly, spending exactly the amount specified. This is a crucial part of the framework, as exceeding the budget (or falling below budget) by even a constant factor would yield a competitiveness which is exponential in the depth of the tree.

This DFS exploration method is very different from previous algorithms, and enables us to get our improved results. The counter-based structure of our algorithms enables this DFS exploration while controlling the budget. Using the counter-based structure is, in turn, enabled by the techniques that we present in our framework’s analysis.

The framework – analysis. The analysis of the algorithms of this framework require constructing a preflow - a weighted directed graph which is similar to a flow network, but in which we allow nonnegative excesses at nodes (i.e. more incoming than outgoing). We refer to nodes of the preflow as charging nodes. We construct a source charging node, from which the output is proportional to the cost of the optimum, and then use the preflow to propagate this output throughout the preflow graph. Since the excesses are nonnegative, the sum of the excesses of any subset of charging nodes is a lower bound of the total output from the source charging node, and thus also some lower bound on the cost of the optimum. We construct the preflow in a manner that allows us to locate such a subset of high-excess charging nodes, thus providing the required lower bound.

In the preflows we construct, each tree element (node or edge) is converted to multiple charging nodes, each corresponding to an exploration of that tree element. The possible edges between charging nodes in the preflow depend on the structure of the tree and the operation of our algorithm. Of those possible edges, we describe a procedure that chooses the actual edges of the preflow. This procedure depends on the optimal solution. Though the original metric space is a tree, the multiple copies of each tree element cause the resulting preflow to be a general directed graph.

The goal of the preflow creation procedure is to propagate the optimum’s costs to some “top layer” of charging nodes. This top layer usually consists of nodes corresponding to explorations of the root tree element, though in the case of online service with delay the definition is different. The charging nodes of that top layer are then chosen to lower bound the optimum, as described.

The preflow creation procedure involves creating colors at the “top” layer of the charging nodes. These colors are then propagated, through some set of propagation rules, to nodes in lower layers. Each color corresponds to the charging node in which it originated, with the exception of two colors – the empty color, and an additional “special” color. As nodes are colored, the possible edges that contain them become actual edges of the preflow.

We now discuss the techniques used in each of the problems in this paper.

**Online facility location with deadlines. **We use our framework in constructing an algorithm for this problem over an HST. The algorithm maintains a counter on each node (other than the root node), such that each counter is of size $f$, where $f$ is the cost of opening a facility. Whenever a counter is full, it resets and triggers an exploration of that node. Whenever the deadline of a pending request expires, the algorithm starts an exploration of the root node.

In the exploration of a node $u$, the algorithm opens a facility at $u$, and considers pending requests in the node’s subtree according to increasing deadline. For each request considered, it raises the counter of the child node on the path to the request by the cost of connecting that request to $u$. If the counter of the child is full, an exploration of that child is called recursively, which would surely serve the considered request. Otherwise, the algorithm connects that request to $u$. As per the framework, the budget of $u$’s exploration for raising these counters is exactly $f$.

**Online facility location with delay. **The algorithm for this problem is an extension of the deadline case. An exploration of the root node is now triggered upon a set of requests which is critical, i.e. has accumulated large delay.

The significant difference between the delay case and the deadline case is in the exploration itself. In the deadline case, the exploration of a node $u$ spends its budget attempting to “push back” the next occurrence of a single event (i.e. the earliest deadline of a pending request in the subtree rooted at $u$). In the delay case, there are two events to consider. The first event is a single request with a delay large enough to justify connection to $u$. The second event is a “coalition” of many tightly-grouped requests with small individual delay, but large overall delay. This coalition does not justify connection to $u$, but does merit opening a facility near the coalition.

Online multilevel aggregation with delay. In our algorithm for this problem over HSTs, each edge has a counter. The size of the counter is the weight of edge. This is in contrast to our algorithms for the facility location problems, in which all counters were of the same size. We assume, without loss of generality, that there exists a single edge exiting the root node, called the root edge. As in the facility location case, an exploration of the root edge is triggered when the delay of a set of requests becomes high.

In our algorithm, exploring an edge means adding descendant edges to the transmitted subtree. The explored edge again has a budget equal to its weight. The exploration repeatedly chooses the earliest point in time in which the delay of a set of requests exceeds the cost of expanding the transmission to include these requests. It then raises the counter of the descendant edge in the direction of that request set. Note the contrast with the algorithms for facility location – the explored edge is allowed to raise the counters of its descendant edges, and not just of its immediate children.

While the analysis for our facility location problems required constructing a single preflow to get a lower bound on the cost of the optimum, the analysis for online multilevel aggregation with delay requires constructing an additional preflow to get an upper bound on the cost of the algorithm.

**Online service with delay. **Our algorithm for this problem uses the exploration method of the algorithm for online multilevel aggregation with delay. However, the tree to be explored is not the entire tree, but rather some subtree according to the location of the server. The concepts of relative trees and major edges are defined in a similar way to [5]. We also use a potential function based on the distance of the algorithm’s server from the optimum’s server. As the algorithm consists (mainly) of making calls to the multilevel aggregation exploration, the analysis divides these explorations to those for which the optimum can be charged (using similar arguments to the analysis of the multilevel aggregation algorithm), and explorations for which the costs are covered by the potential function.

Related Work

The online multilevel aggregation problem generalizes a range of studied problems, such as the TCP acknowledgment problem [14, 17, 22] and the joint replenishment problem [8, 12, 15]. For both the deadline and delay variants of online multilevel aggregation, the best known lower bounds are only constant [8]. Bienkowski et al. [7] were the first to present an algorithm for the online multilevel aggregation problem with arbitrary delay functions, which is $O(D^{4}2^{D})$-competitive. Buchbinder et al. [13] presented an $O(D)$-competitive algorithm for the special case of deadlines.

The problem of online service with delay was presented in [5], along with the $O(\log^{4}n)$-competitive randomized algorithm for a general metric space of $n$ points. The problem has also been studied over specific metric spaces, such as uniform metric and line metric, in which improved results can be achieved [5, 11].

Another metric optimization problem with delay is the problem of matching with delay [2, 19, 18, 4, 9, 10]. For this problem, arbitrary delay functions are intractable, and thus the main line of work focuses on linear delay functions.

Additional problems with delay exist other than those over a metric space. The set aggregation problem, presented in [16], is a variant of set cover with delay. The problem of bin packing with delay is presented in [3].

The classic online facility location problem, suggested by Meyerson [23], has also been studied [21, 1]. In this problem, requests arrive one after the other, and the algorithm must either connect a request to an existing facility immediately upon the request’s arrival, or open a facility at the request’s location. This problem is different from the problems of facility location with deadlines and facility location with delay presented in this paper. The main difference is that in our problems, a facility is only opened momentarily, which only allows immediate connection of pending requests. In contrast, an opened facility in the online facility location of [23] is permanent, allowing the connection of any future request to that facility.

Paper Organization

Section 2 presents the problem of online facility location with deadlines, and an $O(\log^{2}n)$-competitive randomized algorithm for the problem, as well as its analysis. Section 3 discusses the more general problem of online facility location with delay, and extending the algorithm for the deadline case in section 2 to an $O(\log^{2}n)$-competitive algorithm for the case of delay.

Section 4 presents the $O(D^{2})$-competitive deterministic algorithm for online multilevel aggregation with delay. Section 5 presents the $O(\log^{2}n)$-competitive randomized algorithm for online service with delay, which relies on the algorithm for online multilevel aggregation with delay given in Section 4.

2 Online Facility Location with Deadlines

2.1 Problem and Notation

In the online facility location with deadlines problem, requests arrive on points of a metric space over time. Each request is associated with a deadline, by which it must be served. An algorithm for the problem can choose, in any point in time, to open a facility at any point in the metric space momentarily, at a cost of $f$. Immediately upon opening the facility, the algorithm must choose the subset of pending requests (i.e. requests that have arrived but have not been served) to connect to the facility. The cost of connecting each request to the facility is the distance between the request’s location and the facility’s location. Connecting a request to a facility serves that request. Immediately after connecting the requests, the facility disappears. We allow opening a facility at the same point more than once, at different times.

Formally, we are given a metric space $\mathcal{A}=(A,\delta_{\mathcal{A}})$ such that $|A|=n$. A request is a tuple $q=(v_{q},r_{q},d_{q})$ such that $v_{q}$ is a point in $\mathcal{A}$, the arrival time of the request is $r_{q}$ and the deadline of the request is $d_{q}$. We assume, without loss of generality, that all deadlines are distinct. For any instance of the problem, the algorithm’s solution has two costs. The first is the buying cost (or opening cost) $\mathrm{ALG}^{B}=mf$, where $m$ is the number of facilities opened by the algorithm. Denoting by $Q$ the set of requests in the instance, and denoting by $\beta_{q}$ the location of the facility to which the algorithm connects request $q$, the second cost of the algorithm is the connection cost $\mathrm{ALG}^{C}=\sum_{q\in Q}\delta_{\mathcal{A}}(v_{q},\beta_{q})$. Wherever a single metric space $\mathcal{A}$ is considered, we write $\delta=\delta_{\mathcal{A}}$.

The goal of the algorithm is to minimize the total cost, which is

[TABLE]

For the special case in which $A$ is a tree $T$, and $\delta$ is the distance between nodes in $T$, we denote the root of $T$ by $r$ and the weight function on the edges of the tree by $w$. We assume, without loss of generality, that the requests only arrive on leaves of the tree.

The following definitions regarding trees are used throughout the paper.

Definition 2.1**.**

For every tree node $u\in T$, we use the following notations:

• •

For $u\neq r$, we denote by $p(u)$ the parent of $u$ in the tree.

• •

We denote by $T_{u}$ the subtree rooted at $u$.

• •

For a set of requests $Q\subseteq T_{u}$, we denote by $T_{u}^{Q}\subseteq T_{u}$ the subtree spanned by $u$ and the leaves of $Q$.

• •

We define the height of $u$ to be the depth of $T_{u}$.

The following definition is similar to the usual definition of a $\beta$-HST, except that we allow a child edge to be strictly smaller than $\frac{1}{\beta}$ times its parent edge.

Definition 2.2** ($\left(\geq\beta\right)$-HST).**

A rooted tree $T$ is a $\left(\geq\beta\right)$-HST if for any two edges $e,e^{\prime}\in T$ such that $e$ is a parent edge of $e^{\prime}$, we have that $w(e)\geq\beta w(e^{\prime})$.

When considering the problem over a tree $T$, we assume, without loss of generality, that $w(e)\leq f$ for any edge $e\in T$. Indeed, if this is not the case, no request would be connected over $e$, effectively yielding two disjoint instances of the problem.

In this section, we prove the following theorem.

Theorem 2.3**.**

There exists an $O(\log^{2}n)$-competitive randomized algorithm for online facility location with deadlines for any metric space of $n$ points.

2.2 Algorithm for HSTs

We present an algorithm for facility location with deadlines on a $\left(\geq 2\right)$-HST $T$ of depth $D$. We denote the root of the tree by $r$.

We make the assumption that the total weight of any path from the root to a leaf is at most $f$. In a $\left(\geq 2\right)$-HST, the total weight of such a path is at most twice the weight of the top edge, which is at most $f$. Thus, this assumption only costs us a constant factor of $2$ in competitiveness.

Without loss of generality, we allow the algorithm to open facilities on internal nodes of the tree. Indeed, any algorithm that opens facilities on internal nodes can be converted to an algorithm that only opens facilities on leaves in the following manner. Consider a facility opened by the original algorithm on the internal node $u$, and denote by $Q$ the set of requests connected to that facility. The modified algorithm would open the facility at $v_{q^{\ast}}$ instead, where $q^{\ast}=\arg\min_{q\in Q}\delta(u,v_{q})$, and connect the original requests. Through triangle inequality, the connection cost of the modified algorithm is at most twice larger.

**Algorithm’s description. **The algorithm for facility location with deadlines on a $\left(\geq 2\right)$-HST is given in Algorithm 1. The algorithm waits until the deadline of a pending request. It then begins exploring the root node. An exploration of a node $u$ consists of considering the pending requests in $T_{u}$ by order of increasing deadline. The exploration has a budget of exactly $f$ to spend on raising counters of child nodes – it maintains that budget in the variable $b_{u}$. When considering a request $q$, the algorithm raises the counter of the child node $v$, denoted $c_{v}$ in the algorithm, for the child node $v$ in the request’s direction. The counter is raised by the smallest of $\delta(v_{q},u)$, the amount required to fill $c_{v}$, and the remaining budget $b_{u}$. If this fills the counter of $v$, the exploration of $u$ is paused, and a new exploration of $v$ is started, in a DFS manner. We claim, in the analysis, that this exploration of $v$ connects $q.$ Otherwise, the request $q$ is connected to $u$.

The operation of the algorithm is visualized in Figure 6 of Appendix A.

2.3 Analysis

Fix any instance of online facility location with deadlines on a $\left(\geq 2\right)$-HST. Let $\mathrm{OPT}$ be any solution to the instance. We denote by $\mathrm{OPT}^{B}$ the total buying cost of $\mathrm{OPT}$, and by $\mathrm{OPT}^{C}$ the total connection cost of $\mathrm{OPT}$. Denote by $\mathrm{ALG}$ the total cost of the solution of Algorithm 1 for this problem. In this subsection, we prove the following theorem.

Theorem 2.4**.**

$\mathrm{ALG}\leq O(D^{2})\cdot\mathrm{OPT}^{B}+O(D)\cdot\mathrm{OPT}^{C}$.

To prove Theorem 2.4, we show validity of the algorithm, an upper bound for $\mathrm{ALG}$ and a lower bound for $\mathrm{OPT}$.

Throughout the analysis, we denote by $k$ the number of calls to UponDeadline made by the algorithm. We also denote by $t_{1},...,t_{k}$ the times of these $k$ calls, by increasing order.

2.3.1 Validity of the Algorithm

The following proposition and its corollary show that the algorithm is valid.

Proposition 2.5**.**

Let $q$ be a request considered in a call to $\textnormal{{Explore}}(u)$. Then $q$ is served when $\textnormal{{Explore}}(u)$ returns.

Proof.

This is guaranteed by the condition check at the end of the main loop in Explore. ∎

Corollary 2.6**.**

Every request is served by its deadline. That is, the algorithm is valid.

Proof.

Observe that upon the deadline of a request $q$, $\textnormal{{Explore}}(r)$ is called, and immediately considers $q$. Proposition 2.5 concludes the proof. ∎

2.3.2 Upper Bounding $\mathrm{ALG}$

We now proceed to bound $\mathrm{ALG}$ by proving the following lemma.

Lemma 2.7**.**

$\mathrm{ALG}\leq 3\cdot(D+1)\cdot kf$.

The proof of Lemma 2.7 is through providing an upper bound for the cumulative amount by which counters are raised in the algorithm, then bounding the cost of the algorithm by that cumulative amount.

Observation 2.8**.**

Observe any node $u$, and consider a call to $\textnormal{{Explore}}(u)$. Denote by $x$ the total amount by which $\textnormal{{Explore}}(u)$ increases the counters of its children nodes through calls to Invest. Then we have that $x\leq f$. Moreover, if there exists a pending request in $T_{u}$ after the return of $\textnormal{{Explore}}(u)$, then $x=f$.

From the previous observation, the following observation follows.

Observation 2.9**.**

For any $u$, $\textnormal{{Explore}}(u)$ is called at most once at any time $t$.

Using the last observation, we refer to a call to $\textnormal{{Explore}}(u)$ at time $t$ by $\textnormal{{Explore}}_{t}(u)$.

Observe the state of each counter in the algorithm over time. The counter undergoes phases, such that in the start of each phase its value is [math]. The counter increases in value during the phase until it reaches $f$, and is then reset to [math], triggering a service and the end of the phase.

We define a virtual counter $\bar{c}_{u}$ which contains the cumulative value of $c_{u}$. That is, whenever $c_{u}$ increases, $\bar{c}_{u}$ increases by the same amount, but $\bar{c}_{u}$ is never reset when $c_{u}$ is reset. For the sake of analysis, we also consider a virtual counter $\bar{c}_{r}$, which is raised by $f$ whenever $\textnormal{{Explore}}(r)$ is called.

We define \bar{C}_{j}=\sum_{\text{node u$at depth$j}}\bar{c}_{u}. Observe that $\bar{C}_{0}=\bar{c}_{r}$.

Proposition 2.10**.**

For every $j\in[D]$, $\bar{C}_{j}\leq\bar{C}_{j-1}$.

Proof.

Observe that the counters at depth $j$ are raised only upon a call to $\textnormal{{Explore}}(u)$ for a node $u$ at depth $j-1$. \texttt{\textnormal{{Explore}}}(u) is only called after $\bar{c}_{u}$ is raised by $f$, and every such call raises counters at depth $j$ by at most $f$ (using Observation 2.8). ∎

Corollary 2.11**.**

$\sum_{u\in T}\bar{c}_{u}\leq(D+1)kf$.

Proof.

Observe that $\bar{C}_{0}=\bar{c}_{r}=kf$. Using Proposition 2.10, we have that

[TABLE]

∎

Proposition 2.12**.**

Suppose the function $\textnormal{{Explore}}(u)$ calls $\textnormal{{Invest}}(u,v,x)$ when considering request $q$. Then at least one of the following holds:

$\textnormal{{Invest}}(u,v,x)$* returns $x$.* 2. 2.

$b_{u}=0$* after the return of Invest.* 3. 3.

The condition check in Explore of whether $q$ is still pending fails.

Proof.

If $\textnormal{{Invest}}(u,v,x)$ does not return $x$, and $b_{u}\neq 0$ after its return, then it must be that $c_{v}=f$. In this case, $\textnormal{{Explore}}(u)$ calls $\textnormal{{Explore}}(v)$ when checking the condition after the return of Invest. Request $q$ is the pending request with earliest deadline under $T_{u}$, and thus also under $T_{v}$. Hence, $q$ is immediately considered by $\textnormal{{Explore}}(v)$, and is thus served by the end of $\textnormal{{Explore}}(v)$ by Proposition 2.5. ∎

Proposition 2.13**.**

$\mathrm{ALG}\leq 3\cdot\sum_{u\in T}\bar{c}_{u}$**

Proof.

The costs of the algorithm (both opening and connection) are contained in calls to the function Explore (where we associate the opening costs in Open to the Explore call that invoked it). In each call to \texttt{\textnormal{{Explore}}}(u), the algorithm has a cost of $f$ in opening a facility at $u$.

In addition, the algorithm incurs connection costs, as $\textnormal{{Explore}}(u)$ connects any considered request if it is still pending at the end of the loop’s iteration. From Proposition 2.12, if $\textnormal{{Explore}}(u)$ connects a request $q$, then either the preceding $\textnormal{{Invest}}(u,v,\delta(u,v_{q}))$ returned $\delta(u,v_{q})$, or $b_{u}=0$ after the return of that call to Invest.

Observe the calls to $\textnormal{{Invest}}(u,v,\delta(u,v_{q}))$ that return $\delta(u,v_{q})$. For those requests, the connection cost of $q$ is exactly the return value of Invest. But the return values of Invest sum to at most the initial value of $b_{u}$, which is $f$. Thus, connection costs for those requests sum to at most $f$.

As for calls to Invest after which we have that $b_{u}=0$, observe that there is at most one such call, after which the loop in Explore ends. The connection cost for the request considered in this iteration is $\delta(u,v_{q})\leq f$.

Overall, the connection costs in $\textnormal{{Explore}}(u)$ sum to at most $2f.$

Thus, in each call to \texttt{\textnormal{{Explore}}}(u), the total cost of the algorithm (buying and connection) is at most $3f$. Observing that \texttt{\textnormal{{Explore}}}(u) is called only upon raising $\bar{c}_{u}$ by $f$ concludes the proof. ∎

Proof of Lemma 2.7.

The lemma results directly from Proposition 2.13 and Corollary 2.11. ∎

2.3.3 Lower Bounding $\mathrm{OPT}$

We now lower bound the cost of $\mathrm{OPT}$.

Charging nodes and incurred costs.

We define a charging node to be a tuple $(u,[\tau_{1},\tau_{2}])$ such that $u\in T$, and $\tau_{1},\tau_{2}$ are two subsequent times in which $\textnormal{{Explore}}(u)$ is called. We allow the charging nodes of the form $(u,[\tau_{1},\tau_{2}])$ in which $\tau_{1}=-\infty$ and $\tau_{2}$ is the first time in which $\textnormal{{Explore}}(u)$ is called. Similarly, we allow the charging nodes $(u,[\tau_{1},\tau_{2}])$ in which $\tau_{1}$ is the last time $\textnormal{{Explore}}(u)$ is called, and $\tau_{2}=\infty$. We denote by $M$ the set of charging nodes.

For a charging node $\mu=(u,[\tau_{1},\tau_{2}])$, we define the following.

Let *$c_{b}(\mu)$ *be the buying cost incurred by $\mathrm{OPT}$ in $\mu$, defined to be the total cost at which $\mathrm{OPT}$ opened facilities in $T_{u}$ during $[\tau_{1},\tau_{2}]$. 2. 2.

Let $c_{c}(\mu)$ be the *connection cost incurred by $\mathrm{OPT}$ in $\mu$, *defined to be $\sum_{q\in Q}\delta(p(u),v_{q})$, where $Q$ is the set of requests $q$ such that $v_{q}\in T_{u}$, $r_{q}\in[\tau_{1},\tau_{2}]$ and $\mathrm{OPT}$ connected $q$ to a facility outside $T_{u}$.

Let $c(\mu)=c_{b}(\mu)+c_{c}(\mu)$ be the total cost $\mathrm{OPT}$ incurred in $\mu$.

Lemma 2.14**.**

$\sum_{\mu}c(\mu)\leq 2(D+1)\cdot\mathrm{OPT}^{B}+4\cdot\mathrm{OPT}^{C}$.

Proof.

We consider each action of $\mathrm{OPT}$ and how it affects the incurred cost at various charging nodes.

For a facility that is opened by $\mathrm{OPT}$ at node $u$ at time $t$ to participate in $c_{b}((u^{\prime},[\tau_{1},\tau_{2}]))$, we must have that $u\in T_{u^{\prime}}$. Hence, $u^{\prime}$ is on the branch from the root to $u$, and thus $u^{\prime}$ is one of at most $D+1$ possible nodes. We also have that $t\in[\tau_{1},\tau_{2}]$. Using Observation 2.9, we have that $\tau_{2}>\tau_{1}$, and therefore $t$ can belong to at most two such intervals, for every choice of $u^{\prime}$. This yields that the cost of each facility opened by $\mathrm{OPT}$ is counted in $\sum_{\mu}c_{b}(\mu)$** **at most $2(D+1)$ times.

As for connection costs, consider a request $q$ that $\mathrm{OPT}$ connects to a facility at node $v$. Denote by $u$ the least common ancestor of $v$ and $v_{q}$. If $\mathrm{OPT}$ incurs connection cost due to $q$ in charging node $(u^{\prime},[\tau_{1},\tau_{2}])$, then $v_{q}\in T_{u^{\prime}}$ and $v\notin T_{u^{\prime}}$. Therefore, $u^{\prime}$ must be on the path from $v_{q}$ to $u$ (including $v_{q}$, and not including $u$). Let $u=u^{(0)},u^{(1)},u^{(2)},...,u^{(m)}=v_{q}$ be the path from $u$ to $v_{q}$. As with the buying cost, for every $l\in[m]$, $\mathrm{OPT}$ may incur connection cost due to $q$ in at most $2$ charging nodes of the form $(u^{(l)},[\tau_{1},\tau_{2}])$ for some $\tau_{1},\tau_{2}$. Therefore, denoting the total connection cost of $\mathrm{OPT}$ due to connecting $q$ by $X$, we have that

[TABLE]

Now observe that since the tree is a $\left(\geq 2\right)$-HST, we have that the total weight of any path from a node to a descendant leaf is at most the weight of the node’s ancestor edge. Therefore, for every $l\in[m]$:

[TABLE]

Therefore, we have that $\delta(u^{(l)},v_{q})\leq\frac{1}{2^{l}}\cdot\delta(u,v_{q})$. Hence:

[TABLE]

Since $u$ is on the path from $v$ to $v_{q}$, we have that $\delta(u,v_{q})\leq\delta(v,v_{q})$. Hence $X$ is at most $4$ times the connection cost of $\mathrm{OPT}$ for $q$. This concludes the lemma. ∎

Definition 2.15** (excess).**

Let $G=(V^{\prime},E)$ be a directed multigraph, with a non-negative weight function $\alpha:E\rightarrow R^{+}$ defined on its edges. We denote by $E_{v}^{+}\subseteq E$ the set of edges entering node $v$, and by $E_{v}^{-}\subseteq E$ the set of edges leaving $v$. We define the *excess at a node $v\in V^{\prime}$ *to be $\chi_{v}=\sum_{\sigma\in E_{v}^{+}}\alpha(\sigma)-\sum_{\sigma\in E_{v}^{-}}\alpha(\sigma)$.

Note that every edge $\sigma\in E$ from $u$ to $v$ is counted in $\chi_{u}$ and $\chi_{v}$ with opposite signs. The following observation follows.

Observation 2.16**.**

For any $G=(V^{\prime},E)$ and weights $\alpha:E\to\mathbb{R}^{+}$, we have $\sum_{v\in V^{\prime}}\chi_{v}=0$.

Definition 2.17**.**

For a graph $G=(V^{\prime}=V\cup\{s\},E)$ and non-negative weights $\alpha:E\rightarrow\mathbb{R}^{+}$, We say that $Z=(G,s,\alpha)$ is a *preflow *if for every node $v\neq s$ we have that $\chi_{v}\geq 0$. We call $s$ the *source node *of the preflow.

Observation 2.16 yields that $\chi_{s}\leq 0$ for every preflow $Z=(G,s,\alpha)$. We write $\omega_{Z}=-\chi_{s}$.

Proposition 2.18**.**

For $G=(V\cup\{s\},E)$ a directed graph, for weights $\alpha:E\to\mathbb{R}^{+}$ such that $Z=(G,s,\alpha)$ is a preflow, and for every $S\subseteq V$, we have $\sum_{v\in S}\chi_{v}\leq\omega_{Z}$.

Proof.

Observation 2.16 and the definition of a preflow, we get $\sum_{v\in S}\chi_{v}\leq\sum_{v\in V}\chi_{v}=-\chi_{s}=\omega_{Z}$. ∎

We now construct a preflow to lower bound $\mathrm{OPT}$. The graph $G$ underlying the preflow has the set of nodes $M\cup\{s\}$, where $M$ is the set of charging nodes and $s$ is a source node.

Consider a charging node $\mu=(u,[\tau_{1},\tau_{2}])$. We have that $[\tau_{1},\tau_{2}]$ corresponds to a phase of the counter $c_{u}$, since $c_{u}$ was empty at $\tau_{1}$ and was filled and emptied again until time $\tau_{2}$.

Definition 2.19** (Investing).**

Observe two charging nodes $\mu=(u,[\tau_{1},\tau_{2}])$ and $\mu^{\prime}=(u^{\prime}=p(u),[\tau_{1}^{\prime},\tau_{2}^{\prime}])$. We say that $\mu^{\prime}$ *invested $x$ in $\mu$ *if the function call $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$ increased $c_{u}$ by $x$, through calls to Invest, during the phase of $c_{u}$ between $\tau_{1}$ and $\tau_{2}$.

Definition 2.20** ($\lambda_{u}^{t}$ and $\lambda_{\mu}$).**

For every function call $\textnormal{{Explore}}_{t}(u)$ for some $u\in T$ and time $t$, we denote by $\lambda_{u}^{t}$ the earliest deadline of a pending request in $T_{u}$ immediately after the return of $\textnormal{{Explore}}_{t}(u)$ (if there are no pending requests in $T_{u}$, we write $\lambda_{u}^{t}=\infty$).

In addition, for a charging node $\mu=(u,[\tau_{1},\tau_{2}])$ with $\tau_{1}\neq-\infty$, we write $\lambda_{\mu}=\lambda_{u}^{\tau_{1}}$.

Possible edges.

We describe the set of possible edges in $G$ from nodes in $M$ to other nodes in $M$, denoted by $\bar{E}$, and the weight function $\alpha:\bar{E}\rightarrow\mathbb{R}^{+}$. The final set of edges added to $G$ by Procedure 3 from the nodes of $M$ to themselves is a subset of $\bar{E}$. The set $\bar{E}$ contains an edge $\sigma$ from any charging node $\mu_{1}=(u_{1},[\tau_{1}^{1},\tau_{2}^{1}])$ to any charging node $\mu_{2}=(u_{2},[\tau_{1}^{2},\tau_{2}^{2}])$ if $\mu_{1}$ invested in $\mu_{2}$. We set the weight $\alpha(\sigma)$ to be the amount that $\mu_{1}$ invested in $\mu_{2}$.

In the analysis of the preflow $Z=(G,s,\alpha)$ resulting from this procedure, we refer to the values of the variables used in the procedure in their final state.

Proposition 2.21**.**

For every charging node $\mu=(u,[\tau_{1},\tau_{2}])\in M$, we have that $\sum_{\sigma\in E_{\mu}^{-}}\alpha(\sigma)\leq f$.

Proof.

Observe that $E_{\mu}^{-}$ is a subset of $\bar{E}$. In $\bar{E}$, the sum of $\alpha(\sigma)$ over edges $\sigma$ outgoing from $\mu$ is exactly the amount $\mu$ invested in other charging nodes, which is at most $f$. ∎

Corollary 2.22**.**

For a charging node $\mu\in M$ in which $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq f$ we have $\chi_{\mu}\geq 0$.

Proposition 2.23**.**

Let $\mu=(u,[\tau_{1},\tau_{2}])$ be such that $\texttt{Color}[\mu]=\mu^{\star}$ for some charging node $\mu^{\star}=(r,[\tau_{1}^{\star},\tau_{2}^{\star}])$. Then $\mathrm{OPT}$ did not open a facility in $T_{u}$ during $[\tau_{1},\tau_{2}^{\star}]$.

Proof.

Since $\texttt{Color}[\mu]\neq\texttt{Special}$, we have that $\mathrm{OPT}$ did not open a facility in $T_{u}$ during $[\tau_{1},\tau_{2}]$.

The proof is by induction on the depth of $u$. If $u=r$, then it must be that $\mu=\mu^{\star}$, completing the proof. Otherwise, observe the node $\mu^{\prime}=(p(u),[\tau_{1}^{\prime},\tau_{2}^{\prime}])$ from which $\mu$ inherited its color. By the induction hypothesis, $\mathrm{OPT}$ did not open a facility in $T_{p(u)}$ during $[\tau_{1}^{\prime},\tau_{2}^{\star}]$. Since there exists an edge from $\mu$ to $\mu^{\prime}$, we must have that $\tau_{1}^{\prime}\in[\tau_{1},\tau_{2}]$, which completes the proof. ∎

Lemma 2.24**.**

$Z=(G,s,\alpha)$* is a preflow. That is, for every charging node $\mu=(u,[\tau_{1},\tau_{2}])\in M$ we have $\chi_{\mu}\geq 0$.*

Proof.

We observe the following cases according to the final values of the variables in the graph construction procedure.

Case 1: \texttt{\texttt{Color}}[\mu]=\texttt{Special}. In this case, $\mathrm{OPT}$ opened a facility in $T_{u}$ during $[\tau_{1},\tau_{2}]$, implying that $c(\mu)\geq f$. In the initialization of Procedure 3, an edge $\sigma$ from $s$ to $\mu$ with $\alpha(\sigma)=c(\mu)\geq f$ is created, and thus Corollary 2.22 implies that $\chi_{\mu}\geq 0$.

Case 2: $\texttt{Color}[\mu]=\mu^{\star}$ for some charging node $\mu^{\star}$. In this case, incoming edges to $\mu$ were added, with a total weight which is the total amount invested by $\mu$. Since $\texttt{Color}[\mu]=\mu^{\star}$ was set by SetColor, we must have that $\tau_{1}\neq-\infty$ and that $\lambda_{\mu}<\infty$. Using Observation 2.8, we have that $\textnormal{{Explore}}_{\tau_{1}}(u)$ raised counters by a total of exactly $f$. Corollary 2.22 therefore proves the lemma for this case.

Case 3: $\texttt{Color}[\mu]=\texttt{None}$. Observe any edge $\sigma\in E_{\mu}^{-}$, incoming to some node $\mu^{\prime}=(u^{\prime},[\tau_{1}^{\prime},\tau_{2}^{\prime}])$. It must be that $\texttt{{Color}}[\mu^{\prime}]=\mu^{\star}$, for some charging node $\mu^{\star}=(r,[\tau_{1}^{\star},\tau_{2}^{\star}])$. Note that $\mu^{\prime}$ invested in $\mu$, and thus $\tau_{1}^{\prime}\in[\tau_{1},\tau_{2}]$. Combining Proposition 2.23 for $\mu^{\prime}$ and the fact that $\texttt{Color}[\mu]\neq\texttt{Special}$, we have that $\mathrm{OPT}$ did not open a facility in $T_{u}$ during $[\tau_{1},\tau_{2}^{\star}]$.

We therefore have that for every request $q$ such that $v_{q}\in T_{u}$ and $[r_{q},d_{q}]\subseteq[\tau_{1},\tau_{2}^{\star}]$, $\mathrm{OPT}$ must connect $q$ to some facility at a node $v\notin T_{u}$. If it also holds that $r_{q}\leq\tau_{2}$, then $\mathrm{OPT}$ incurs a connection cost of $\delta(v_{q},u^{\prime})$ in $\mu$ on connecting $q$. We proceed to find such requests $q$.

Now observe that $\mu^{\prime}$ invested $\alpha(\sigma)$ in $\mu$. Thus, there exists a set of requests $L_{\sigma}$ that are considered in $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$ such that $\alpha(\sigma)\leq\sum_{q\in L_{\sigma}}\delta(a_{q},u^{\prime})$ and $a_{q}\in T_{u}$ for every $q\in L_{\sigma}$. Since the requests of $L_{\sigma}$ are considered in $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$, we have that $\lambda_{\mu^{\prime}}\geq d_{q}$ for every $q\in L_{\sigma}$. Since $\texttt{Color}[\mu^{\prime}]=\mu^{\star}$, we have that $\lambda_{\mu^{\prime}}\leq\tau_{2}^{\star}$, and thus $d_{q}\leq\tau_{2}^{\star}$.

Observe any $q\in L_{\sigma}$. It holds that $r_{q}\leq\tau_{1}^{\prime}\leq\tau_{2}$, since $q$ is considered in $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$. Now, observe that $\texttt{Color}[\mu]=\texttt{None}$ even though $\texttt{Color}[\mu^{\prime}]=\mu^{\star}$. Hence, either $\tau_{1}=-\infty$ or $\lambda_{\mu}>\tau_{2}^{\star}$. If $\tau_{1}=-\infty$, then $r_{q}\geq\tau_{1}$. Otherwise, $\tau_{1}\neq-\infty$ and $\lambda_{\mu}>\tau_{2}^{\star}$. Since $d_{q}\leq\tau_{2}^{\star}$, it must be that $q$ was not pending immediately after the return of $\textnormal{{Explore}}_{\tau_{1}}(u)$. However, $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$ considered $q$ when raising $c_{u}$ toward $\textnormal{{Explore}}_{\tau_{2}}(u)$. Thus, $q$ was released after $\tau_{1}$.

Overall, for every $q\in L_{\sigma}$ we have that $r_{q}\in[\tau_{1},\tau_{2}]$ and $d_{q}\leq\tau_{2}^{\star}$. Thus, $\mathrm{OPT}$ incurs a connection cost of at least $\sum_{q\in L_{\sigma}}\delta(v_{q},u^{(1)})$ in the charging node $\mu$ due to $L_{\sigma}$, which is at least $\alpha(\sigma)$.

Now, if for every distinct $\sigma_{1},\sigma_{2}\in E_{\mu}^{-}$ we have that $L_{\sigma_{1}}\cap L_{\sigma_{2}}=\emptyset$, then the connection cost $\mathrm{OPT}$ incurs in $\mu$ is at least $\sum_{\sigma\in E_{\mu}^{-}}\alpha(\sigma)$. Indeed, observe that $\sigma_{1}$ and $\sigma_{2}$ enter two distinct charging nodes $\mu^{(1)}=(p(u),[\tau_{1}^{(1)},\tau_{2}^{(1)}])$ and $\mu^{(2)}=(p(u),[\tau_{1}^{(2)},\tau_{2}^{(2)}])$. Lemma 2.9 implies that $\tau_{1}^{(1)}\neq\tau_{1}^{(2)}$. It is enough to observe that for $b\in\{1,2\}$, each request $q\in L_{\sigma_{b}}$ is pending before $\tau_{1}^{(b)}$ and is served after $\tau_{1}^{(b)}$.

Overall, we have that $c(\mu)\geq\sum_{\sigma\in E_{\mu}^{-}}\alpha(\sigma)$. In the initialization of Procedure 3, an edge $\sigma$ from $s$ to $\mu$ with $\alpha(\sigma)=c(\mu)$ is created, and thus $\chi_{\mu}\geq 0$ as required. This concludes the proof of the current case, and the lemma. ∎

Lemma 2.25**.**

For each $i\in[k]$ and charging node $\mu=(r,[t_{i-1},t_{i}])$, we have $\chi_{\mu}\geq f$.

Proof.

Observe that $E_{\mu}^{-}=\emptyset$. It remains to see that $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq f$.

If $\texttt{Color}[\mu]\neq\texttt{None}$, it holds that $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq f$ identically to Cases 1 and 2 in Lemma 2.24.

Otherwise, we must have that $\textnormal{{SetColor}}(\mu,\mu)$ returned None. Thus, it must be that either $t_{i-1}=-\infty$ or $\lambda_{\mu}>t_{i}$. We claim that either of these cases contradicts $\texttt{Color}[\mu]\neq\texttt{Special}$. Indeed, observe that $\textnormal{{Explore}}_{t_{i}}(r)$ is called upon a deadline of a request $q$. If $t_{i-1}=-\infty$, it holds that $r_{q}\geq t_{i-1}$. If $\lambda_{\mu}>t_{i}$, it must be that $r_{q}\geq t_{i-1}$ as well. Overall, $[r_{q},d_{q}]\in[t_{i-1},t_{i}]$, and thus $\mathrm{OPT}$ must open a facility in that interval, in contradiction. ∎

Lemma 2.26**.**

$kf\leq 2(D+1)\cdot\mathrm{OPT}^{B}+4\cdot\mathrm{OPT}^{C}$**

Proof.

Lemma 2.24 yields that $Z$ is a valid preflow. For $i\in[k]$, let $\mu_{i}=(r,[t_{i-1},t_{i}])$. Using Lemma 2.25 and Proposition 2.18, we have that

[TABLE]

Now observe that $E_{s}^{+}=\emptyset$, and that $\sum_{\sigma\in E_{s}^{-}}\alpha(\sigma)=\sum_{\mu\in M}c(\mu)$. Using Lemma 2.14, we obtain

[TABLE]

as required. ∎

Proof of Theorem 2.4.

Combining Lemmas 2.7 and 2.26, we have that

[TABLE]

∎

Remark 2.27*.*

Our algorithm and its analysis also work in the case that the cost of opening a facility is different between nodes in the tree, as long as the cost of opening a facility at a node is at least the cost of opening a facility at its parent node. If this is not the case, observe that the analysis of Case 1 of Lemma 2.24 would no longer hold.

2.4 From HST to General Metric Space

In this subsection, we show how the deterministic Algorithm 1 for $\left(\geq 2\right)$-HSTs yields a randomized $O(\log^{2}n)$-competitive algorithm for facility location with deadlines on a general metric space with $n$ points, thus proving Theorem 2.3. To do this, we consider a standard probabilistic embedding of a metric space to an HST.

Theorem 2.28**.**

For any metric space $\mathcal{X}=(X,\delta_{\mathcal{X}})$ such that $|\mathcal{X}|=n$, there exists a distribution $\mathcal{D}$ over $\left(\geq 2\right)$-HSTs of depth $O(\log n)$ such that $X$ are the leaves of the HST, such that the expected distortion is $O(\log n)$. That is, for every $x_{1},x_{2}\in X$ we have that

[TABLE]

where $\delta_{\mathcal{T}}$ is the distance in the tree $\mathcal{T}$.

Theorem 2.28 is a direct result of composing the embeddings of Fakcharoenphol et al. [20] and Bansal et al. [6].

We observe the following randomized algorithm for facility location with delay on a general metric space:

Embed the metric space to a $\left(\geq 2\right)$-HST according to the distribution in Theorem 2.28. 2. 2.

Run Algorithm 1 on the resulting $\left(\geq 2\right)$-HST.

Proof of Theorem 2.3.

We show that the randomized algorithm described above is indeed $O(\log^{2}n)$-competitive. Fix any instance of facility location with deadlines. We denote by $\mathrm{ALG}^{\mathcal{T}}$ the cost of the algorithm on the instance with regard to distances on the chosen $\left(\geq 2\right)$-HST $\mathcal{T}$. Since $\delta_{\mathcal{T}}(x_{1},x_{2})\geq\delta_{\mathcal{X}}(x_{1},x_{2})$, we have that $\mathrm{ALG}^{\mathcal{X}}\leq\mathrm{ALG}^{\mathcal{T}}$, where $\mathrm{ALG}^{\mathcal{X}}$ is the actual cost incurred by the algorithm on this instance.

From Theorem 2.4, we know that for any solution $\mathrm{OPT}^{\mathcal{T}}$ for the instance on $\mathcal{T}$, it holds that $\mathrm{ALG}^{\mathcal{T}}\leq O(D^{2})\cdot\mathrm{OPT}^{\mathcal{T},B}+O(D)\cdot\mathrm{OPT}^{\mathcal{T},C}$ , where $D$ is the depth of $\mathcal{T}$ (and thus $D=O(\log n)$).

Now, denote by $\mathrm{OPT}^{\mathcal{X}}$ the optimal solution for the instance over $\mathcal{X}$. Observe that for every $\mathcal{T}$ in the support of $\mathcal{D}$, $\mathrm{OPT}$ yields a solution $\mathrm{OPT}^{\mathcal{T}}$ by opening facilities at the same locations, at the same times, and connecting the same requests. It holds that $\mathrm{OPT}^{\mathcal{T},B}=\mathrm{OPT}^{\mathcal{X},B}$, and that $\mathbb{E}_{\mathcal{T}\sim\mathcal{D}}\left[\mathrm{OPT}^{\mathcal{T},C}\right]\leq O(\log n)\cdot\mathrm{OPT}^{\mathcal{X},C}$.

Combining the above facts, we have that

[TABLE]

proving the theorem. ∎

The reasoning behind the main theorem of this subsection is that the connection cost is distorted upon HST embedding, while the buying cost is not. Thus, the HST algorithm is allowed to lose a larger factor over $\mathrm{OPT}^{B}$ ($\Theta(\log^{2}n)$) compared to the factor it loses over $\mathrm{OPT}^{C}$ ($\Theta(\log n)$). This property is used to analyze the other problems considered in this paper in a similar manner.

Remark 2.29*.*

For the case of different costs for opening facilities at different points in the metric space, we obtain a $O(\log^{2}\Delta+\log\Delta\log n)$-competitive randomized algorithm, with $\Delta$ the aspect ratio of the metric space, in the following manner. We use the embedding of Fakcharoenphol et al. [20] without composing it with the embedidng of [6]. This yields a 2-HST (rather than a $\left(\geq 2\right)$-HST), which has a depth of $O(\log\Delta)$, with $\Delta$ the aspect ratio of the original metric space. This tree has an distortion of $O(\log n)$.

In this $2$-HST, for each node $u$, the distances between $u$ and the leaves in $T_{u}$ are equal. Thus, we can allow the algorithm to open a facility at $u$, at a cost which is the minimal cost of opening a facility at a leaf in $T_{u}$, at a loss of a factor of $2$ in connection cost. The resulting tree has non-decreasing opening costs from the root to any leaf, and is (in particular) a $\left(\geq 2\right)$-HST of depth $D=O(\log\Delta)$. Thus, using the algorithm for $\left(\geq 2\right)$-HSTs and Remark 2.27, and applying the distortion of $O(\log n)$ to the connection cost as in the proof of Theorem 3.1, we obtain the $O(\log^{2}\Delta+\log\Delta\log n)$-competitive algorithm.

3 Facility Location with Delay

3.1 Problem and Notation

We now describe the facility location with delay problem. The problem is an extension of the facility location with deadlines problem, in which the deadline for each request $q$ is replaced with an arbitrary delay function $d_{q}(t)$ associated with that request. Each delay function is required to be continuous and monotonically non-decreasing. This is indeed an extension of the deadline problem, as a deadline can be described as a step function, which goes from [math] to infinity at the time of the deadline. Such a step function can be approximated arbitrarily well by a continuous delay function.

A feasible solution for a facility location with delay instance consists of opening facilities and connecting each request to some facility, as in the deadline case. In addition to the opening costs and connection costs incurred, the solution also pays $d_{q}(t)$ for each request $q$ connected at time $t$. Overall, for an instance of the problem with requests $Q$, the algorithm incurs the delay cost $\mathrm{ALG}^{D}=\sum_{q\in Q}d_{q}(t_{q})$, where $t_{q}$ is the time in which $q$ is served by the algorithm. Thus, the algorithm’s goal is to minimize the total cost

[TABLE]

Without loss of generality, we assume that $d_{q}(r_{q})=0$. Indeed, if this is not the case, observe that any solution (including the optimal one) must pay this initial amount of $d_{q}(r_{q})$ in delay for that request, which only reduces the competitive ratio of any online algorithm.

In this section, we prove the following theorem.

Theorem 3.1**.**

There exists an $O(\log^{2}n)$-competitive randomized algorithm for facility location with delay for a general metric space of size $n$.

3.2 Algorithm for HSTs

In this subsection, we present a deterministic algorithm for facility location with delay on a $\left(\geq 2\right)$-HST. This algorithm yields a randomized $O(\log^{2}n)$-competitive algorithm for general metric spaces, in a similar way to the deadline case.

We require the following definitions.

Definition 3.2** (Solution).**

Let $Q$ be a set of requests. For $S\subseteq X$, and a function $\phi:Q\rightarrow S$ we say that $(S,\phi)$ is a *solution for *$Q$, with a cost $|S|\cdot f+\sum_{q\in Q}\delta(v_{q},\phi(q))$. If $S\subseteq T_{u}$ for some node $u$, we write that $(S,\phi)$ is a solution for $Q$ under $u$.

Definition 3.3** (Ancestor-closed solution).**

Let $Q$ be a set of requests, and let $(S,\phi)$ be a solution for $Q$ under a node $u$. We say that $(S,\phi)$ is an *ancestor-closed solution for $Q$ under $u$ *if for every $s\in S$ such that $s\neq u$ we have that $p(s)\in S$.

If $u=r$, we simply write that $(S,\phi)$ is an ancestor-closed solution for $Q$.

Definition 3.4** ($\psi(Q)$ and $\psi_{u}(Q)$).**

We define $\psi(Q)$ to be the cost of the minimal-cost ancestor-closed solution for $Q$. Similarly, we define $\psi_{u}(Q)$ to be the cost of the minimal-cost ancestor-closed solution for $Q$ under $u$.

Definition 3.5** (Critical request set).**

We say that a set of pending requests $Q$ at time $t$ is *critical *if $d_{Q}(t)\geq\psi(Q)$.

**Algorithm’s description. **Our algorithm is given in Algorithm 5. The algorithm calls UponCritical whenever a set of pending requests $Q$ becomes critical. It uses the Open and Invest functions from Algorithm 1, but redefines the Explore function. The function call $\textnormal{{Explore}}(u)$ now forwards time until the first occurrence of one of two events.

The first event is a pending request $q$ in $T_{u}$, the delay of which exceeds the cost of connecting it to $u$. Handling this event is similar to handling the event considered in Algorithm 1 – we attempt to raise the counter of the child node $v$ in $q$’s direction by $\delta(u,v_{q})$. If this fills the counter of $v$, this triggers an immediate call to $\textnormal{{Explore}}(v)$. However, in contrast to the deadline case, calling $\textnormal{{Explore}}(v)$ is not guaranteed to connect the request $q$. For this reason, $\textnormal{{Explore}}(u)$ must invest the remainder of $\delta(u,v_{q})$ (or until $b_{u}=0$) in $v$’s counter before connecting $q$ to $u$.

The second event is not analogous to the deadline case. In this event, for a child $v$ of $u$ and a “coalition” of pending requests $Q$ in $T_{v}$, we have that the delay of $Q$ exceeds $\psi_{v}(Q)$. In this case, the algorithm invests in $v$ until either it is out of budget ($b_{u}=0$) or $v$’s counter is full $(c_{v}=f$). It is important to note that in contrast to the first event, the fact that $\textnormal{{Explore}}(u)$ considered $Q$ does not provide any guarantees for connecting the requests of $Q$.

Algorithm 5 changes $\textnormal{{Explore}}(u)$ so that time is forwarded until one of two events happens, rather than the single event in Algorithm 1 (i.e. expired deadline). These two events are shown in Figure 4.

3.3 Analysis

Fix any instance of facility location with delay on a $\left(\geq 2\right)$-HST.

Theorem 3.6**.**

$\mathrm{ALG}\leq O(D^{2})\cdot\mathrm{OPT}^{B}+O(D)\cdot\mathrm{OPT}^{C}+O(D^{2})\cdot\mathrm{OPT}^{D}$.

Observe that the connection cost is distorted by the embedding, while the buying and delay costs are not. Thus, using an identical argument to the proof of Theorem 2.3 of the deadline problem, Theorem 3.6 implies Theorem 3.1.

We devote this subsection to prove Theorem 3.6.

3.3.1 Upper Bounding $\mathrm{ALG}$

To upper bound the cost of the algorithm, we show the following Lemma.

Lemma 3.7**.**

$\mathrm{ALG}\leq 6\cdot(D+1)\cdot kf$**

Proposition 3.8**.**

$\mathrm{ALG}^{D}\leq\mathrm{ALG}^{B}+\mathrm{ALG}^{C}$**

Proof.

The algorithm explicitly maintains that for every set of pending requests $Q$ at any time $t$ we have that $\psi(Q)\geq d_{Q}(t)$. Now, consider that since the delay of a pending request goes to infinity, the algorithm ultimately serves every request. Consider a specific service made by the algorithm, described by a solution $(S,\phi)$ to some set of requests $Q$, and note that $(S,\phi)$ is an ancestor-closed solution to $Q$. Thus, its total cost is at least $\psi(Q)$, completing the proof. ∎

Lemma 3.9**.**

$\mathrm{ALG}^{B}+\mathrm{ALG}^{C}\leq 3\cdot(D+1)\cdot kf$.

Proving Lemma 3.9 is very similar to proving Lemma 2.7 of the deadline case. Defining cumulative counters as in the deadline case, we can prove Corollary 2.11 holds in the delay case using an identical proof. It remains to show and prove analogues to Propositions 2.12 and 2.13.

Note that the connection costs in $\textnormal{{Explore}}(u)$ only occur during iterations of the main loop in which the main if condition is entered.

Proposition 3.10** (analogue of Proposition 2.12 ).**

*Suppose the function $\textnormal{{Explore}}(u)$ enters the main **if *condition in an iteration, and let $q$ be the pending request under consideration. Then at least one of the following holds:

The sum of return values of calls to Invest in that iteration is $\delta(u,v_{q})$. 2. 2.

$b_{u}=0$* at the end of the iteration.* 3. 3.

$q$* is no longer pending after the first call to Invest.*

Proof.

Consider the state after the return of the first call to Invest. Either Invest returned $\delta(u,v_{q})$, or $b_{u}=0$, or $c_{v}=f$. In the first two cases, we are done. In the third case, $\textnormal{{Explore}}(u)$ then calls $\textnormal{{Explore}}(v)$. If $q$ is connected during $\textnormal{{Explore}}(v)$, we are done. Otherwise, $\textnormal{{Explore}}(u)$ enters the nested **if **condition upon observing that $q$ is still pending.

Denote by $y$ the return value of the first call to Invest, and consider the return value of the second call to Invest made in the nested if. If the return value is $\delta(u,v_{q})-y$, we are done. Otherwise, consider that $c_{v}=0$ before the call to Invest, and since $\delta(u,v_{q})-y\leq f$ it must thus be that $b_{u}=0$ after the return of the second call to Invest. This concludes the proof. ∎

Proposition 3.11** (analogue of Proposition 2.13).**

$\mathrm{ALG}^{B}+\mathrm{ALG}^{C}\leq 3\cdot\sum_{u\in T}\bar{c}_{u}$**

Proof.

The costs of the algorithm (both opening and connection) are again contained in calls to Explore, as in the proof of Proposition 2.13. Each call to $\textnormal{{Explore}}(u)$ has an opening cost of $f$.

As for connection costs, note that they only occur in iterations of the main loop in $\textnormal{{Explore}}(u)$ in which the main **if **condition is entered, and not in the else condition. In each iteration in which the main if condition is entered, a request $q$ is considered, which may be connected to $u$ at cost $\delta(u,v_{q})$. Through Proposition 3.10, in each such iteration either the return values of calls to Invest sum to $\delta(u,v_{q})$ (and thus $b_{u}$ decreases by $\delta(u,v_{q})$), $b_{u}=0$ at the end of the iteration (in which case this is the last iteration), or $\textnormal{{Explore}}(u)$ does not connect $q$.

Since $b_{u}$ can decrease by at most $f$, the connection cost of the algorithm is bounded by $f+\delta(u,v_{q})$ for $q$ the last request considered, which is at most $2f$.

Noting that the total cost of $\textnormal{{Explore}}(u)$ is at most $3f$, and that $\bar{c}_{u}$ is raised by $f$ before calling $\textnormal{{Explore}}(u)$ yields the proposition. ∎

Proof of Lemma 3.9.

Results directly from Proposition 3.11 and Corollary 2.11 (which holds for the delay case as well). ∎

Proof of Lemma 3.7.

The lemma results directly from Proposition 3.8 and Lemma 3.9. ∎

3.3.2 Lower Bounding $\mathrm{OPT}$

To lower bound the cost of the optimum, we prove the following lemma, which is analogous to Lemma 2.26 of the deadline case.

Lemma 3.12**.**

$kf\leq(D+1)\cdot\mathrm{OPT}^{B}+2\cdot\mathrm{OPT}^{C}+(D+1)\cdot\mathrm{OPT}^{D}$.

Charging nodes and incurred costs.

We again use charging nodes, defined as in the deadline case. However, the charging nodes for the delay case use half-closed intervals instead of the closed intervals of the deadline case. The reason for this is that we do not have the guarantee that only one call to UponCritical is made at a given time, so that using closed intervals would break the analogue of Lemma 2.14 for our case.

Let $M$ be the set of charging nodes. The definitions of $c_{b}(\mu)$ (buying costs) and $c_{c}(\mu)$ (connection costs) are identical to the definition in the deadline case. For the delay case, we also define incurring *delay *costs,

Definition 3.13** ($c_{d}(\mu)$).**

Let $\mu=(u,[\tau_{1},\tau_{2}))$ be a charging node. Let $c_{d}(\mu)$ be the *delay cost incurred by $\mathrm{OPT}$ on *$\mu$, defined to be the total delay cost incurred by $\mathrm{OPT}$ on requests in $T_{u}$ released in $[\tau_{1},\tau_{2})$.

We write $c(\mu)=c_{b}(\mu)+c_{c}(\mu)+c_{d}(\mu)$.

We use Procedure 3 to create the preflow. However, we give a different definition to $\lambda$ than in the deadline case. The definition follows.

Definition 3.14** ($\lambda_{u}^{t}$ and $\lambda_{\mu}$).**

For every function call $\textnormal{{Explore}}_{t}(u)$ for some $u\in T$ and time $t$, let $Q$ be the set of requests pending in $T_{u}$ immediately after the return of $\textnormal{{Explore}}(u)$. We define $\lambda_{u}^{t}$ to be the first time $t^{\prime}\geq t$ in which one of the following conditions occurs:

There is a request $q\in Q$ such that $d_{q}(t^{\prime})\geq\delta(v_{q},u)$. 2. 2.

There exists a set of requests $Q^{\prime}\subseteq Q$ such that $Q^{\prime}\subseteq T_{u^{\prime}}$, for some $u^{\prime}$ a child of $u$, and also $d_{Q^{\prime}}(t^{\prime})\geq\psi_{u^{\prime}}(Q^{\prime})$.

Like in the deadline case, we write $\lambda_{\mu}=\lambda_{u}^{\tau_{1}}$ where $\mu=(u,[\tau_{1},\tau_{2}))$.

Lemma 3.15**.**

$\sum_{\mu}c(\mu)\leq(D+1)\cdot\mathrm{OPT}^{B}+2\cdot\mathrm{OPT}^{C}+(D+1)\cdot\mathrm{OPT}^{D}$.

Proof.

$\sum_{\mu}c_{b}(\mu)$ can be charged to $(D+1)\cdot\mathrm{OPT}^{B}$ and $\sum_{\mu}c_{c}(\mu)$ can be charged to $2\cdot\mathrm{OPT}^{C}$ as in Lemma 2.14 (since the intervals are not closed, this improves by a factor of $2$). It remains to charge $\sum_{\mu}c_{d}(\mu)$ to $(D+1)\cdot\mathrm{OPT}^{D}$. To do so, observe that the delay incurred by $\mathrm{OPT}$ on a request $q$ can only be counted in charging nodes with intervals containing $r_{q}$, and defined by a node which is an ancestor of $v_{q}$. There are at most $D+1$ such nodes. ∎

Observation 3.16**.**

Let $(S,\phi)$ be a minimal-cost ancestor-closed solution for $Q$ under $u$. Then it holds for every $q\in Q$ that $\phi(q)$ the least ancestor of $v_{q}$ in $S$.

Observation 3.17**.**

Let $(S,\phi)$ be a minimal-cost ancestor-closed solution for $Q$ under $u$. Let $u^{\prime}\in S$ be a descendant of $u$. Observing the set $Q^{\prime}=Q\cap T_{u^{\prime}}$, we have that $(S\cap T_{u^{\prime}},\phi\restriction_{Q^{\prime}})$ is a minimal-cost ancestor-closed solution for $Q^{\prime}$ under $u^{\prime}$.

Proposition 3.18** (Decomposition of minimum-cost ancestor-closed solutions).**

Let $(S,\phi)$ be a minimum-cost ancestor-closed solution for $Q\subseteq T_{u}$ under $u$, and let $\bar{S}\subseteq S$ be the children of $u$ in $S$. Define $Q_{1}^{u^{\prime}}=Q\cap T_{u^{\prime}}$, and define $Q_{2}=Q\backslash\left(\bigcup_{u^{\prime}\in\bar{S}}Q_{1}^{u^{\prime}}\right)$. Then

[TABLE]

Proof.

For every $u^{\prime}\in\bar{S}$, Observation 3.16 implies that the requests of $Q_{1}^{u^{\prime}}$ only connect to facilities in $S\cap T_{u^{\prime}}$. The opening costs of $S\cap T_{u^{\prime}}$, plus the connection costs of $Q_{1}^{u^{\prime}}$, are exactly $\psi_{u^{\prime}}(Q_{1}^{u^{\prime}})$ according to Observation 3.17, for a total of $\sum_{u^{\prime}\in\bar{S}}\psi_{u^{\prime}}(Q_{1}^{u^{\prime}})$.

In addition, opening the facility at $u$ costs $f$. Observation 3.16 implies that the requests of $Q_{2}$ are connected to the facility at $u$, at a total cost of $\sum_{q\in Q_{2}}\delta(u,v_{q})$. This finishes the proof of the proposition. ∎

Lemma 3.19**.**

$\chi_{\mu}\geq 0$* for every $\mu=(u,[\tau_{1},\tau_{2}))\in M$. That is, the preflow $Z=(G,s,\alpha)$ defined in Procedure 3 is valid.*

Proof.

We observe the following cases for $\mu$.

Case 1: $\texttt{Color}[\mu]=\texttt{Special}$. This case is identical to Case 1 in Lemma 2.24.

Case 2: $\texttt{Color}[\mu]=\mu^{\star}$ for a charging node $\mu^{\star}$. Again, this case is similar to Case 2 in Lemma 2.24.

From now on, assume we are not in the previous two cases, and thus $\texttt{Color}[\mu]=\texttt{None}$. Every outgoing edge from $\mu$ to some charging node $\mu^{\prime}=(u^{\prime},[\tau_{1}^{\prime},\tau_{2}^{\prime}))$ is created from $\mu^{\prime}$ investing in $\mu$, which means that $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$ raised the counter $c_{u}$ towards $\textnormal{{Explore}}_{\tau_{2}}(u)$.

**Case 3: **For every such $\mu^{\prime}$, we have that $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$ raised $c_{u}$ towards $\textnormal{{Explore}}_{\tau_{2}}(u)$ only through calls to Invest inside the main **if **condition of Explore, and not through the main **else **condition. In this case, we show that $c_{c}(\mu)+c_{d}(\mu)\geq\sum_{\sigma\in E_{\mu}^{-}}\alpha(\sigma)$, proving the lemma for this case. The proof is almost identical to the proof of Case 3 of Lemma 2.24, in which we showed for the deadline case that $c_{c}(\mu)\geq\sum_{\sigma\in E_{\mu}^{-}}\alpha(\sigma)$. The argument for the deadline case consisted of finding a set of requests which the optimum had to connect, all released in $[\tau_{1},\tau_{2})$. The difference between our delay case and the deadline case is that $\mathrm{OPT}$ might choose not to connect some of those requests, in which case it must incur a delay cost which is at least its connection cost.

**Case 4: **There exists an outgoing edge from $\mu$ to a charging node $\mu^{\prime}=(u^{\prime},[\tau_{1}^{\prime},\tau_{2}^{\prime}))$, such that $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$ raised $c_{u}$ towards $\textnormal{{Explore}}_{\tau_{2}}(u)$ through calls to Invest inside the main **else **condition of Explore. Let $\texttt{Color}[\mu^{\prime}]=\mu^{\star}=(r,[\tau_{1}^{\star},\tau_{2}^{\star}))$. Observing that Proposition 2.23 holds for the delay problem as well, and using $\texttt{Color}[\mu]\neq\texttt{Special}$, we have that $\mathrm{OPT}$ did not open a facility in $T_{u}$ during $[\tau_{1},\tau_{2}^{\star})$.

Since $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(u^{\prime})$ raised $c_{u}$ towards $\textnormal{{Explore}}_{\tau_{2}}(u)$ inside the main **else **condition, there was a set $Q$ of requests pending at $\tau_{1}^{\prime}$ such that there exists a time $\hat{t}\leq\lambda_{\mu^{\prime}}\leq t_{i}$ in which $d_{Q}(\hat{t})\geq\psi_{u}(Q)$. In addition, the main **else **condition is only reached if $t_{1}^{\prime}>t_{2}^{\prime}=\hat{t}$. Thus, for every request $q\in Q$ we have that $d_{q}(\hat{t})<\delta(u^{\prime},v_{q})$.

Observe that every $q\in Q$ is pending at $\tau_{1}^{\prime}\leq\tau_{2}$, and thus released prior to $\tau_{2}$. Showing that $r_{q}\geq\tau_{1}$, together with the fact that $\mathrm{OPT}$ did not open a server in $T_{u}$ during $[\tau_{1},\tau_{2}^{\star})$, would yield that $\mathrm{OPT}$ either:

• •

connected $q$ to a facility outside $T_{u}$ at a cost of at least $\delta(v_{q},p(u)=u^{\prime})$, which is at least $d_{q}(\hat{t})$, or

• •

did not connect $q$ until time $\tau_{2}^{\star}$, in which case it paid a delay cost of $d_{q}(\tau_{2}^{\star})\geq d_{q}(\hat{t})$.

In either case, $\mathrm{OPT}$ paid at least $d_{q}(\hat{t})$ in delay and connection costs on $q$. Since we have that $r_{q}\in[\tau_{1},\tau_{2})$, we have that $\mathrm{OPT}$ incurred a cost of $d_{q}(\hat{t})$ in $u$ due to $q$. It remains to find a set of such requests $Q^{\prime}\subseteq Q$ such that $r_{q}\geq\tau_{1}$ for every $q\in Q^{\prime}$, and such that $d_{Q^{\prime}}(\hat{t})\geq f$.

**Claim: **there exists a set of requests $Q^{\prime}\subseteq Q$ such that $r_{q}\geq\tau_{1}$ for every $q\in Q^{\prime}$, and such that $d_{Q^{\prime}}(\hat{t})\geq f$.

Now, since $\texttt{Color}[u]=\texttt{None}$, we have that either $\tau_{1}=-\infty$ or $\lambda_{\mu}>\tau_{2}^{\star}$. If $\tau_{1}=-\infty$, then $r_{q}\geq\tau_{1}$ for every $q\in Q$. Since $d_{Q}(\hat{t})\geq\psi_{u}(Q)\geq f$, choosing $Q^{\prime}=Q$ completes the proof of the claim.

Otherwise, $\tau_{1}\neq-\infty$ and $\lambda_{\mu}>t_{i}$. Let $(S,\phi)$ be the minimal-cost ancestor-closed solution for $Q$ under $u$. Defining $\bar{S},Q_{2}$, and $Q_{1}^{u^{\prime}}$ for every $u^{\prime}\in\bar{S}$ as in Proposition 3.18, we have that

[TABLE]

Now, denote by $\hat{Q}\subseteq Q$ the subset of $Q$ that was pending immediately after $\textnormal{{Explore}}_{\tau_{1}}(u)$. We make the following observations.

For every $q\in Q_{2}$, we have that $d_{q}(\hat{t})\geq\delta(v_{q},u)$. Otherwise, $Q\backslash\{q\}$ would become critical before $\hat{t}$. But since $\lambda_{\mu}>\tau_{2}^{\star}\geq\hat{t}$, we must have that $q\notin\hat{Q}$. Thus, $Q_{2}\cap\hat{Q}=\emptyset$. 2. 2.

Writing $\hat{Q}_{1}^{u^{\prime}}=\hat{Q}\cap Q_{1}^{u^{\prime}}$, we observe that since $\lambda_{\mu}>\hat{t}$, we have that $d_{\hat{Q}_{1}^{u^{\prime}}}(\hat{t})\leq\psi_{u^{\prime}}(\hat{Q}_{1}^{u^{\prime}})\leq\psi_{u^{\prime}}(Q_{1}^{u^{\prime}})$

Overall, we get that

[TABLE]

Thus, we have that

[TABLE]

Observing that $r_{q}\geq\tau_{1}$ for each $q\in Q\backslash\hat{Q}$ yields the claim, and thus the lemma. ∎

Lemma 3.20**.**

For every $i\in[k]$, the charging node $\mu=(r,[t_{i-1},t_{i}))$ has $\chi_{\mu}\geq f$.

Proof.

Observe that $E_{\mu}^{-}=\emptyset$. It remains to see that $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)=f$.

If $\texttt{Color}[\mu]\neq\texttt{None}$, this holds similarly to Lemma 2.25.

Otherwise, assume that $\texttt{Color}[\mu]=\texttt{None}$. Since $\texttt{Color}[\mu]\neq\texttt{Special}$, $\mathrm{OPT}$ did not open a facility in $[t_{i-1},t_{i})$. We find a set of requests $Q^{\prime}$ released in $[t_{i-1},t_{i})$ on which $\mathrm{OPT}$ incurs at least $f$ delay. The argument that follows is similar to that of Case 4 of Lemma 3.19, the structure of which we repeat for clarity.

We must have that either $t_{i-1}=-\infty$ or $\lambda_{\mu}>t_{i}$. Denote by $Q$ the set of requests that triggered the service at $t_{i}$. We have that $d_{Q}(t_{i})\geq\psi(Q)$. Observe that $r_{q}<t_{i}$ for every $q\in Q$. If $t_{i-1}=-\infty$, then $r_{q}\geq t_{i-1}$ for every $q\in Q$, and since $\psi(Q)\geq f$ the proof is complete.

Otherwise, $\lambda_{\mu}>t_{i}$. Denoting by $(S,\phi)$ the minimum-cost ancestor-closed solution for $Q$, we define $\bar{S}$, $Q_{2}$ and $Q_{1}^{u^{\prime}}$ for every $u^{\prime}\in S$ as in Proposition 3.18. Proposition 3.18 yields

[TABLE]

Define $\hat{Q}\subseteq Q$ to be the subset of $Q$ alive immediately after the return of $\textnormal{{Explore}}_{t_{i-1}}(r)$. Using $\lambda_{\mu}>t_{i}$, and choosing $\hat{t}=t_{i}$, we use an identical argument to Case 4 of Lemma 3.19 to show that

[TABLE]

Choosing $Q^{\prime}=Q\backslash\hat{Q}$ completes the proof of lemma, identically to Case 4 of Lemma 3.19. ∎

We can now prove Lemma 3.12.

of Lemma 3.12.

Lemma 3.19 yields that $Z$ is a valid preflow. For $i\in[k]$, let $\mu_{i}=(r,[t_{i-1},t_{i}))$. Using Lemma 3.20 and Proposition 2.18, we have that

[TABLE]

Now observe that $E_{s}^{+}=\emptyset$, and that $\sum_{\sigma\in E_{s}^{-}}\alpha(\sigma)=\sum_{\mu\in M}c(\mu)$. Using Lemma 3.15, we obtain

[TABLE]

as required. ∎

Proof of Theorem 3.6.

Using Lemmas 3.7 and 3.12 completes the proof. ∎

4 Online Multilevel Aggregation with Delay

4.1 Problem and Notation

In the online multilevel aggregation with delay problem, requests arrive on the leaves of a rooted tree over time. Each such request accumulates delay until served. At any point in time, an algorithm for this problem may choose to transmit a subtree which contains the root, at a cost which is the weight of that subtree. Any pending requests on a leaf in the transmitted subtree are served by the transmission.

Formally, as in the facility location with delay problem, a request is a tuple $(v_{q},r_{q},d_{q}(t))$ where the leaf of the request is $v_{q}$, the arrival time of the request is $r_{q}$ and $d_{q}(t)$ is the request’s delay function. The function $d_{q}(t)$ is again required to be non-decreasing and continuous.

We observe online multilevel aggregation with delay on a $\left(\geq 2\right)$-HST. We assume, without loss of generality, that only a single edge exits the root node, called the root edge. Otherwise, we operate on each edge that exits the root node separately, as there is no interaction between the subtrees rooted at those edges. We denote the tree by $T$, and its root edge by $r$.

For a request $q$, and a set of edges $E$ we write that $q\in E$ if the leaf edge on which $q$ is released is in $E$. In accordance, we write $Q\subseteq E$ if $q\in E$ for every $q\in Q$. For a set of pending requests $Q$ at time $t$, we denote by $d_{Q}(t)$ the total delay incurred by the requests of $Q$ until time $t$. We denote by $w(e)$ the weight of an edge, and by $w(E)=\sum_{e\in E}w(e)$ the total weight of a set of edges.

We assume that each request would gather infinite delay if it remains pending forever.

The following notations are similar to those for facility location, but refer to edges instead of nodes.

Definition 4.1** (Similar to Definition 2.1).**

For every tree edge $e\in T$, we use the following notations:

• •

For $e\neq r$, we denote by $p(e)$ the parent edge of $e$ in the tree.

• •

We denote by $T_{e}$ the subtree rooted at $e$.

• •

For a set of requests $Q\subseteq T_{e}$, we denote by $T_{e}^{Q}\subseteq T_{e}$ the subtree spanned by $e$ and the leaves of $Q$. We denote $T^{Q}=T_{r}^{Q}$.

• •

We define the height of $e$, denoted $h_{e}$, to be the depth of $T_{e}$.

In this section, we prove the following theorem.

Theorem 4.2**.**

There exists a $O(D^{2})$-competitive deterministic algorithm for online multilevel aggregation with delay on any tree of depth $D$.

4.2 Algorithm for HSTs

We now present an algorithm for the online multilevel aggregation with delay problem over a $\left(\geq 2\right)$-HST of depth $D$.

Definition 4.3** (saturation and critical sets).**

For any edge $e$, we say that a set of pending requests $Q\subseteq T_{e}$ *saturates *$T_{e}$ if $d_{Q}(t)\geq w(T_{e}^{Q})$. We say that a set of pending requests $Q$ is critical at time $t$ if $Q$ saturates the root edge $r$.

Upon a set of critical requests, the algorithm starts a service. In every service, the algorithm maintains a tree $\mathcal{T}$, which it expands and ultimately transmits.

Definition 4.4** (live cut).**

At any time during the construction of $\mathcal{T}$, we define the *live cut under $e\in\mathcal{T}$ *to be the set of edges $E=\{e^{\prime}|e^{\prime}\in T_{e}\backslash\mathcal{T}\wedge p(e^{\prime})\in\mathcal{T}\}$.

**Algorithm’s description. **The algorithm is given in Algorithm 6. When a set of requests is critical, a call is made to UponCritical, which resets the tree to transmit $\mathcal{T}$, calls $\textnormal{{Explore}}(r)$ to expand $\mathcal{T}$, then transmits $\mathcal{T}$.

The exploration of an edge $e$ adds $e$ to $\mathcal{T}$. It then considers the live cut underneath $e$, which is the set of potential candidates for expanding $\mathcal{T}$. The exploration forwards time until a set of pending requests saturates $T_{e^{\prime}}$ for an edge $e^{\prime}$ in the the live cut. It then invests in raising the counter of $e^{\prime}$, until either the counter is full (which triggers $\textnormal{{Explore}}(e^{\prime})$ immediately) or $\textnormal{{Explore}}(e)$ is out of budget. The counter of $e$, as well as the budget of $\textnormal{{Explore}}(e)$, is equal to $w(e)$.

Note that the live cut under $e$ can change significantly after every iteration of the loop in $\textnormal{{Explore}}(e)$, as making a recursive call to $\textnormal{{Explore}}(e^{\prime})$ can add many additional edges to $\mathcal{T}$.

4.3 Analysis

Fix any instance of online multilevel aggregation with delay, and observe the behavior of Algorithm 6 for that instance. We denote by $\mathrm{ALG}$ the algorithm’s total cost. We also define $\mathrm{ALG}^{B}$ to be the algorithm’s buying cost, and $\mathrm{ALG}^{D}$ to be the algorithm’s delay cost, such that $\mathrm{ALG}=\mathrm{ALG}^{B}+\mathrm{ALG}^{D}$. We similarly define $\mathrm{OPT},\mathrm{OPT}^{B}$ and $\mathrm{OPT}^{D}$ for the optimal solution for the instance.

In this subsection, we prove the following theorem.

Theorem 4.5**.**

$\mathrm{ALG}\leq O(D)\cdot\mathrm{OPT}^{B}+O(D^{2})\cdot\mathrm{OPT}^{D}$**

In the following analysis, we denote by $k$ the number of times that the algorithm transmits a tree. We also denote the times of the $k$ transmissions by $t_{1},...,t_{k}$ in increasing order.

4.3.1 Upper Bounding $\mathrm{ALG}$

We upper bound the cost of the algorithm by proving the following lemma.

Lemma 4.6**.**

$\mathrm{ALG}\leq 2kDw(r)$**

The main technique used in proving Lemma 4.6 is constructing a preflow to provide an upper bound for $\mathrm{ALG}^{B}$. Bounding $\mathrm{ALG}^{D}$ by $\mathrm{ALG}^{B}$ then yields the lemma.

Observation 4.7**.**

Every call to $\textnormal{{Explore}}(r)$ serves at least one pending request.

Proposition 4.8**.**

Every request is eventually served.

Proof.

Consider a request $q$. As assumed in the model, the delay of $q$ goes to infinity as $q$ remains pending. But at some point, the delay of $q$ would exceed $T_{r}^{\{q\}}$, making $\{q\}$ critical, and triggering calls to $\textnormal{{Explore}}(r)$ until $q$ is served. Each such call serves at least one pending request due to Observation 4.7, and thus $q$ will eventually be served. ∎

The following observation follows from the fact that a tree is transmitted whenever a set of requests becomes critical.

Observation 4.9**.**

At any time $t$ during the algorithm, and for any set of requests $Q$ pending at $t$, it holds that $d_{Q}(t)\leq w(T^{Q})$.

Lemma 4.10**.**

$\mathrm{ALG}^{D}\leq\mathrm{ALG}^{B}$.

Proof.

Denote by $\mathcal{Q}$ the set of all requests released in the instance. Through Proposition 4.8, we can partition $\mathcal{Q}$ into the sets of requests $Q_{i}$, for $i\in k$, such that $Q_{i}$ is served in the $i$’th service. Denote by $T_{i}$ the tree bought by the algorithm in the $i$’th service, and denote by $d(Q_{i})$ the total delay incurred by the algorithm on the requests of $Q_{i}$. To prove the lemma, it is enough to show that $d(Q_{i})\leq w(T_{i})$ for every $i\in[k]$.

Now, observe that since all of $Q_{i}$ are served in $t_{i}$. Therefore, $d(Q_{i})=d_{Q_{i}}(t_{i})$. Since transmitting $T_{i}$ serves $Q_{i}$, we have that $T^{Q_{i}}\subseteq T_{i}$. Using Observation 4.9, we have that $d(Q_{i})\leq w(T_{i})$ as required. ∎

It remains to bound $\mathrm{ALG}^{B}$.

Let $V$ be the set of calls to Explore made by the algorithm. Observe that in the algorithm, whenever an edge $e$ is bought, a call to Explore($e$) is made immediately afterwards. Therefore, we have that $\mathrm{ALG}^{B}=\sum_{\textnormal{{Explore}}_{\tau}(e)\in V}w(e)$.

In addition, immediately prior to calling Explore($e$) the counter $c_{e}$ is zeroed. We say that $\textnormal{{Explore}}_{\tau_{1}}(e_{1})$ *invested *$x$ in $\textnormal{{Explore}}_{\tau_{2}}(e_{2})$ if $\textnormal{{Explore}}_{\tau_{1}}(e_{1})$ raised $c_{e_{2}}$ by $x$, such that the next zeroing of $c_{e_{2}}$ triggers $\textnormal{{Explore}}_{\tau_{2}}(e_{2})$.

We now construct a graph $G=(V\cup\{s\},E)$ and a weight function $\alpha:E\to\mathbb{R}^{+}$, such that $Z=(G,s,\alpha)$ is a preflow. We construct $E$ and $\alpha$ in the following way:

For every $j\in[k]$, and for every root function call $\textnormal{{Explore}}_{\tau}(r)$, add to $E$ an edge $\sigma$ from $s$ to $\textnormal{{Explore}}_{\tau}(r)$, and set $\alpha(\sigma)=D\cdot w(r)$. 2. 2.

For every function call $\textnormal{{Explore}}_{\tau}(e)\in V$, and for each function call $\textnormal{{Explore}}_{\tau^{\prime}}(e^{\prime})\in V$ that invested some amount $x$ in $\textnormal{{Explore}}_{\tau}(e)$, we add to $E$ an edge $\sigma$ from $\textnormal{{Explore}}_{\tau^{\prime}}(e^{\prime})$ to $\textnormal{{Explore}}_{\tau}(e)$, and set $\alpha(\sigma)=h_{e}\cdot x$.

Lemma 4.11**.**

For every $v=\textnormal{{Explore}}_{\tau}(e)\in V$ we have that $\chi_{v}\geq w(e)$, implying that $Z$ is a valid preflow.

Proof.

We first claim that $\sum_{\sigma\in E_{v}^{+}}\alpha(\sigma)\geq h_{e}\cdot w(e)$. If $e=r$, this is true since there exists an edge $\sigma$ from $s$ to $\textnormal{{Explore}}_{\tau}(e)$ such that $\alpha(\sigma)=Dw(r)\geq h_{e}\cdot w(e)$.

Otherwise, observe that the total amount invested in $\textnormal{{Explore}}_{\tau}(e)$ is exactly $w(e)$, and thus $\sum_{\sigma\in E_{v}^{+}}\alpha(\sigma)\geq h_{e}\cdot w(e)$.

Now, observe that $\textnormal{{Explore}}_{\tau}(e)$ invests at most $w(e)$ in counters for edges of height at most $h_{e}-1$, and thus $\sum_{\sigma\in E_{v}^{-}}\alpha(\sigma)\leq(h_{e}-1)\cdot w(e)$. Combining this with the previous claim, we get $\chi_{v}\geq w(e)$ as required. ∎

We can now prove Lemma 4.6.

of Lemma 4.6.

Observe the preflow $Z$. Note that

[TABLE]

Using Lemmas 4.11 and 2.18, we have

[TABLE]

Using Lemma 4.10, we get that $\mathrm{ALG}\leq 2kDw(r)$ as required. ∎

4.3.2 Lower Bounding $\mathrm{OPT}$

The following lemma provides a lower bound on the cost of the optimum.

Lemma 4.12**.**

$kw(r)\leq\mathrm{OPT}^{B}+D\cdot\mathrm{OPT}^{D}$.

Charging nodes and incurred costs.

We now define charging nodes for the analysis of our algorithm. The charging nodes are tuples of the form $(e,[\tau_{1},\tau_{2}))$, such that $\tau_{1}$ and $\tau_{2}$ are two subsequent times in which the edge $e$ is bought. As in the facility location case, we allow $\tau_{1}=-\infty$ and $\tau_{2}=\infty$.

For a charging node $\mu=(e,[\tau_{1},\tau_{2}))$ we say that:

• •

$\mathrm{OPT}$ incurs a *buying cost *of $w(e)$ in $\mu$ if $\mathrm{OPT}$ bought the edge $e$ during $[\tau_{1},\tau_{2})$. We denote the buying cost that $\mathrm{OPT}$ incurs in $\mu$ by $c_{b}(\mu)$.

• •

$\mathrm{OPT}$ incurs a *delay cost *in $\mu$ equal to the delay incurred by $\mathrm{OPT}$ on the set of requests $Q=\{q\in T_{e}|r_{q}\in[\tau_{1},\tau_{2})\}$. We denote the delay cost that $\mathrm{OPT}$ incurs in $\mu$ by $c_{d}(\mu)$.

We denote the total cost that $\mathrm{OPT}$ incurs in $\mu$ by $c(\mu)=c_{b}(\mu)+c_{d}(\mu)$.

Denote by $M$ the set of all charging nodes. To prove Lemma 4.12, we show a preflow on the set of vertices $M\cup\{s\}$, where $s$ is the source node.

The following definition of charging node investment is very similar to the definition for the facility location case.

Definition 4.13** (Investing).**

For two charging nodes $\mu_{1}=(e_{1},[\tau_{1}^{1},\tau_{2}^{1}))$ and $\mu_{2}=(e_{2},[\tau_{1}^{2},\tau_{2}^{2}))$, such that $e_{1}$ is an ancestor of $e_{2}$, we say that $\mu_{1}$ *invested $x$ in $\mu_{2}$ *if $\textnormal{{Explore}}_{\tau_{1}^{1}}(e_{1})$ raised the counter $c_{e_{2}}$ by $x$, through calls to Invest, during the counter phase of $c_{e_{2}}$ between $\tau_{1}^{2}$ and $\tau_{2}^{2}$.

Definition 4.14** ($\lambda_{e}^{t}$ and $\lambda_{\mu}$).**

For every function call $\textnormal{{Explore}}_{t}(e)$ for some edge $e\in T$ and time $t$, let $Q$ be the set of requests pending in $T_{e}$ immediately after the return of $\textnormal{{Explore}}_{t}(e)$. We define $\lambda_{e}^{t}$ to be the first time $t^{\prime}\geq t$ such that there exists $Q^{\prime}\subseteq Q$ such that $d_{t}(Q^{\prime})\geq w(T_{e}^{Q^{\prime}})-w(e)$.

For a charging node $\mu=(e,[\tau_{1},\tau_{2}))$ such that $\tau_{1}\neq-\infty$, we write $\lambda_{\mu}=\lambda_{e}^{\tau_{1}}$.

Possible edges.

We describe the set of possible edges in $G$ from nodes in $M$ to other nodes in $M$, denoted by $\bar{E}$, and the weight function $\alpha:\bar{E}\rightarrow\mathbb{R}^{+}$. The final set of edges added to $G$ by Procedure 8 from the nodes of $M$ to themselves is a subset of $\bar{E}$. The set $\bar{E}$ contains an edge $\sigma$ from any charging node $\mu_{1}\in M$ to any charging node $\mu_{2}\in M$ if $\mu_{1}$ invested in $\mu_{2}$. We set the weight $\alpha(\sigma)$ to be the amount that $\mu_{1}$ invested in $\mu_{2}$.

We can now construct the preflow required for the analysis using Procedure 8. This procedure is very similar to Procedure 3, used for analysis of our algorithms for facility location. It uses the function SetColor as defined in Procedure 3.

The procedure for the construction is given in Procedure 8 very similar to that given in Procedure 3.

Definition 4.15** (Cut).**

We say that a set of edges $H\subseteq T$ is a *cut *if no edge in $H$ is an ancestor of another edge in $H$.

It is easy to verify that any live cut is a cut.

Proposition 4.16**.**

Let $e$ be an edge, and let $H$ be a cut in $T_{e}$ that does not include $e$. Let $Q\subseteq\bigcup_{h\in H}T_{h}$ be a set of pending requests and $t$ be a time such that $d_{Q}(t)\geq w(T_{e}^{Q})-w(e)$. Then there exists an $h\in H$ and a subset $Q_{h}\subseteq Q$ such that $Q_{h}\subseteq T_{h}$ and $d_{Q_{h}}(t)\geq w(T_{h}^{Q_{h}})$.

Proof.

Partition $Q$ into $|H|$ disjoint sets $Q_{h}$ for every $h\in H$, according to the subtree $T_{h}$ in which the requests are. Now, observe that $w(T_{e}^{Q})\geq w(e)+\sum_{h\in H}w(T_{h}^{Q_{h}})$. We thus have that

[TABLE]

and thus there exists $h\in H$ such that $d_{Q_{h}}(t)\geq w(T_{h}^{Q_{h}})$, as required. ∎

Proposition 4.17**.**

Observe the function call $\textnormal{{Explore}}_{t}(e)$, and let $P$ be the set of times chosen as $t^{\prime}$ in $\textnormal{{Explore}}_{t}(e)$. Then for every $t^{\prime}\in P$ we have that $t^{\prime}\leq\lambda_{e}^{t}$.

Proof.

Fix some point during the execution of $\textnormal{{Explore}}_{t}(e)$. Denote by $Q$ the set of pending requests in $T_{e}$, and let $\lambda\geq t$ be the first time such that there exists $Q^{\prime}\subseteq Q$ for which $d_{Q^{\prime}}(\lambda)\geq w(T_{e}^{Q^{\prime}})-w(e)$. Observe the next time chosen as $t^{\prime}$ in $\textnormal{{Explore}}_{t}(e)$. Observe that the subtrees rooted in edges of the current live cut contain all of $Q$. Thus, using Proposition 4.16, we obtain that $t^{\prime}\leq\lambda$.

Since during $\textnormal{{Explore}}_{t}(e)$ requests are being served but do not arrive, we have that $\lambda$ only increases during $\textnormal{{Explore}}_{t}(e)$. Since the final value of $\lambda$ is $\lambda_{e}^{t}$, for every $t^{\prime}\in P$ we have $t^{\prime}\leq\lambda_{e}^{t}$ as required. ∎

Proposition 4.18**.**

For every charging node $\mu=(e,[\tau_{1},\tau_{2}))\in M$, it holds that $\sum_{\sigma\in E_{\mu}^{-}}\alpha(\sigma)\leq w(e)$.

Proof.

Observe that an outgoing edge $\sigma$ from $\mu$ only goes to a node $\mu^{\prime}$ that invested in $\mu$, and is labeled $\alpha(\sigma)=x$ where $x$ is the amount that $\mu^{\prime}$ invested in $\mu$. These amount sum to at most $w(e)$, since the counter $c_{e}$ can only reach $w(e)$ before it is zeroed and $e$ is bought (thus ending the counter phase $[\tau_{1},\tau_{2})$). ∎

Corollary 4.19**.**

Every charging node $\mu\in M$ such that $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq w(e)$ has that $\chi_{\mu}\geq 0$.

The following observation results from the condition checks in SetColor.

Observation 4.20**.**

For any node $\mu=(e,[\tau_{1},\tau_{2}))$ such that $\texttt{Color}[\mu]=\mu^{\star}$ for some charging node $\mu^{\star}$, we have that $\tau_{1}\neq-\infty$, and also $\lambda_{\mu}<\infty$.

The following Proposition is analogous to Proposition 2.23, and its proof is identical.

Proposition 4.21**.**

Let $\mu=(e,[\tau_{1},\tau_{2}))$ such that $\texttt{Color}[\mu]=\mu^{\star}$ for some charging node $\mu^{\star}=(r,[\tau_{1}^{\star},\tau_{2}^{\star}))$. Then $\mathrm{OPT}$ did not transmit $e$ during $[\tau_{1},\tau_{2}^{\star})$.

Lemma 4.22**.**

The preflow defined by Procedure 8 is valid.

Proof.

We need to show that $\chi_{\mu}\geq 0$ for every $\mu=(e,[\tau_{1},\tau_{2}))\in M$.

We consider the following cases:

Case 1: $\texttt{Color}[\mu]=\texttt{Special}$. In this case, we have that $c(\mu)\geq c_{b}(\mu)=w(e)$. Observe that an edge $\sigma$ from $s$ to $\mu$ is created with $\alpha(\sigma)=c(\mu)$, and thus from Corollary 4.19 we have that $\chi_{\mu}\geq 0$.

Case 2: $\texttt{Color}[\mu]=\mu^{\star}$, for some charging node $\mu^{\star}$. Using Observation 4.20, observe that $\tau_{1}\neq-\infty$ and $\lambda_{\mu}<\infty$, and thus the call $\textnormal{{Explore}}_{\tau_{1}}(e)$ has raised counters by exactly $w(e)$, and thus $\mu$ has invested a total of $w(e)$ in other charging nodes. Thus, in $\sum_{\sigma\in\bar{E}_{\mu}^{+}}\alpha(\sigma)=w(e)$. Observe that SetColor added the edges of $\bar{E}_{\mu}^{+}$ to $E$, and thus $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq w(e)$. Using Corollary 4.19, we have that $\chi_{\mu}\geq 0$.

Case 3: $\texttt{Color}[\mu]=\texttt{None}$. If there are no outgoing edges from $\mu$, then clearly $\chi_{\mu}\geq 0$ and we are done. Otherwise, there exists an outgoing edge $\sigma$ to some node $\mu^{\prime}=(e^{\prime},[\tau_{1}^{\prime},\tau_{2}^{\prime}))$ with $\texttt{Color}[\mu^{\prime}]=\mu^{\star}$, for some charging node $\mu^{\star}$. Denote $\mu^{\star}=(r,[\tau_{1}^{\star},\tau_{2}^{\star}))$, and observe that since $\mu^{\prime}$ invested in $\mu$, we must have that $\tau_{1}^{\prime}\leq\tau_{2}$. Using Proposition 4.21, and the fact that $\texttt{Color}[\mu]\neq\texttt{Special}$, we have that $\mathrm{OPT}$ did not transmit $e$ during $[\tau_{1},\tau_{2}^{\star})$.

**Claim – **There exists a set of requests $Q^{\prime}\subseteq T_{e}$ such that $r_{q}\in[\tau_{1},\tau_{2})$ such that $d_{Q^{\prime}}(\tau_{2}^{\star})\geq w(e)$.

Proof of Claim.

Since $\texttt{Color}[\mu^{\prime}]=\mu^{\star}$, it must be that $\tau_{1}^{\prime}\neq-\infty$ and $\lambda_{\mu^{\prime}}\leq\tau_{2}^{\star}$. Since $\mu^{\prime}$ invested in $\mu$, we have that at some point during $\textnormal{{Explore}}_{\tau_{1}^{\prime}}(e^{\prime})$, $e$ was in the live cut under $e^{\prime}$, and the algorithm detected a set of pending requests $Q\subseteq T_{e}$ such that $d_{Q}(\hat{t})\geq w(T_{e}^{Q})$ for some time $\hat{t}\geq\tau_{1}^{\prime}$. From Proposition 4.17, we have that $\hat{t}\leq\lambda_{\mu}\leq\tau_{2}^{\star}$. Note also that since $Q$ is pending at $\tau_{1}^{\prime}$, we have that $r_{q}<\tau_{1}^{\prime}\leq\tau_{2}$. for every $q\in Q$.

Now observe that since $\texttt{Color}[\mu^{\prime}]=\mu^{\star}$, $\texttt{Color}[\mu]=\texttt{None}$, and there exists an edge from $\mu$ to $\mu^{\prime}$, we must have that $\textnormal{{SetColor}}(\mu,\mu^{\star})$ was called. Since $\texttt{Color}[\mu]=\texttt{None}$, it must be that either $\tau_{1}=-\infty$ or $\lambda_{\mu}>\tau_{2}^{\star}$.

If $\tau_{1}=-\infty$, then $r_{q}\geq\tau_{1}$ for every $q\in Q$. Combining this with $r_{q}<\tau_{2}$, we have that $r_{q}\in[\tau_{1},\tau_{2})$ for every $q\in Q$. We also have that $d_{Q}(\tau_{2}^{\star})\geq d_{Q}(\hat{t})\geq w(T_{e}^{Q})\geq w(e)$, by $Q$’s definition. Thus choosing $Q=Q^{\prime}$ proves the claim for this case.

Otherwise, we have that $\tau_{1}\neq-\infty$ and $\lambda_{\mu}>\tau_{2}^{\star}$. We denote by $\hat{Q}\subseteq Q$ the subset of requests pending immediately after the return of $\textnormal{{Explore}}_{\tau_{1}}(e)$. By the definition of $\lambda_{\mu}$, and since $\hat{t}<\lambda_{\mu}$, we have that $d_{\hat{Q}}(\hat{t})<w(T_{e}^{\hat{Q}})-w(e)$. Thus,

[TABLE]

Denote $Q^{\prime}=Q\backslash\hat{Q}$. The requests of $Q^{\prime}$ were not pending immediately during $\textnormal{{Explore}}_{\tau_{1}}(e)$, and therefore $r_{q}\geq\tau_{1}$ for any $q\in Q^{\prime}$. As seen before, for every $q\in Q$ we have that $r_{q}<\tau_{2}$, and thus for any $q\in Q^{\prime}$ we have $r_{q}\in[\tau_{1},\tau_{2})$. $Q^{\prime}$ therefore proves the claim. ∎

We now use the claim. As shown before, $\mathrm{OPT}$ did not buy $e$ during $[\tau_{1},\tau_{2}^{\star})$, and has therefore did not serve any request from $Q^{\prime}$ until time $\tau_{2}^{\star}$. Therefore, $\mathrm{OPT}$ incurs a delay cost of $w(e)$ at $\mu$ on the requests of $Q^{\prime}$, and thus $c(\mu)\geq w(e)$. Observe that an edge $\sigma$ from $s$ to $\mu$ is created with $\alpha(\sigma)=c(\mu)$, and thus Corollary 4.19 implies that $\chi_{\mu}\geq 0$. This concludes the proof of Lemma 4.22. ∎

Lemma 4.23**.**

For every $j\in[k]$, the charging node $\mu=(r,[t_{j-1},t_{j}))$ has that $\chi_{\mu}\geq w(r)$.

Proof.

We denote $\tau_{1}=t_{j-1},\tau_{2}=t_{j}$. Observe that no other nodes invest in $\mu$, and thus $E_{\mu}^{-}=\emptyset$. It remains to show that $\sum_{e\in E_{\mu}^{+}}\alpha(e)\geq w(e)$.

If $\texttt{Color}[\mu]\neq\texttt{None}$, then identically to Cases 1 and 2 of Lemma 4.22, we have that $\sum_{e\in E_{\mu}^{+}}\alpha(e)\geq w(e)$. This completes the proof for these cases.

If $\texttt{Color}[\mu]=\texttt{None}$, then we have a very similar proof to case 3 of Lemma 4.22. Observe the pending requests $Q$ that became critical at $\tau_{2}$, triggering the service. Clearly, $r_{q}<\tau_{2}$ for every $q\in Q$. Observe that $\textnormal{{SetColor}}(\mu,\mu)$ was called, yet $\texttt{Color}[\mu]=\texttt{None}$. Thus, it must be that either $\tau_{1}=-\infty$ or $\lambda_{\mu}>\tau_{2}$. To complete the proof, we need the following claim.

**Claim – **there exists a set of requests $Q^{\prime}$ such that $r_{q}\in[\tau_{1},\tau_{2})$ for every $q\in Q^{\prime}$, and $d_{Q^{\prime}}(\tau_{2})\geq w(r)$.

Proof of Claim.

Observe the two cases of the claim. If $\tau_{1}=-\infty$, then $r_{q}\in[\tau_{1},\tau_{2})$ for every $q\in Q$. Together with the fact that $d_{Q}(\tau_{2})\geq w(T^{Q})\geq w(r)$, choosing $Q^{\prime}=Q$ proves the claim.

Otherwise, $\tau_{1}\neq-\infty$ and $\lambda_{\mu}>\tau_{2}$. In this case, denote by $\hat{Q}\subseteq Q$ the requests of $Q$ pending immediately after $\textnormal{{Explore}}_{\tau_{1}}\{r\}$ and observe, as in Case 3 of Lemma 4.22, that $d_{\hat{Q}}(\tau_{2})\leq w(T^{\hat{Q}})-w(r)\leq w(T^{Q})-w(r)$. Thus, we have that $d_{Q\backslash\hat{Q}}(\tau_{2})\geq w(r)$. Observe that $r_{q}\geq\tau_{1}$ for every $q\in Q\backslash\hat{Q}$, and thus $r_{q}\in[\tau_{1},\tau_{2})$ for every $q\in Q\backslash\hat{Q}$. Thus choosing $Q^{\prime}=Q\backslash\hat{Q}$ yields the claim. ∎

Now, observe that $\texttt{Color}[\mu]\neq\texttt{Special}$ and thus $\mathrm{OPT}$ did not transmit $e$ during $[\tau_{1},\tau_{2})$. Using the claim, $\mathrm{OPT}$ incurred delay cost of at least $w(r)$ on $\mu$ due to $Q^{\prime}$. Thus $c(\mu)\geq w(r)$, and thus $\sum_{e\in E_{\mu}^{+}}\alpha(e)\geq w(r)$, completing the proof of the lemma. ∎

Proposition 4.24**.**

$\omega_{Z}\leq\mathrm{OPT}^{B}+D\cdot\mathrm{OPT}^{D}$**

Proof.

Observe that $E_{s}^{+}=\emptyset$, and that for every $\sigma\in E_{s}^{-}$ to a node $\mu\in M$ we have that $\alpha(\sigma)=c(\mu)$. Therefore, $\omega_{Z}=\sum_{\mu\in M}c(\mu)$.

Observe that for buying an edge $e$ at time $t$, $\mathrm{OPT}$ incurs buying cost only at the unique charging node $(e,[\tau_{1},\tau_{2}))$ such that $t\in[\tau_{1},\tau_{2})$.

In addition, when $\mathrm{OPT}$ incurs delay for a request $q$ released on leaf edge $e$, it incurs delay cost in at most $D$ charging nodes, of the form $(e^{\prime},[\tau_{1},\tau_{2}))$ such that $r_{q}\in[\tau_{1},\tau_{2})$ and $e^{\prime}$ is an ancestor of $e$.

Thus, $\sum_{\mu\in M}c(\mu)\leq\mathrm{OPT}^{B}+D\cdot\mathrm{OPT}^{D}$, proving the proposition. ∎

We can now prove Lemma 4.12.

Proof (of Lemma 4.12).

Observe the set of charging nodes $N=\{(r,[t_{j-1},t_{j})|j\in[k]\}$. Using Lemma 4.23, we have that $\sum_{\mu\in N}\chi_{\mu}\geq kw(r)$.

We now use Propositions 2.18 and 4.24 to obtain

[TABLE]

proving the lemma. ∎

We now prove the main theorem for this subsection.

Proof of Theorem 4.5.

The theorem results immediately from Lemmas 4.6 and 4.12. ∎

4.4 From HSTs to General Trees

In this subsection, we show how to extend our result for multilevel aggregation on $\left(\geq 2\right)$-HSTs to general trees, thus proving Theorem 4.2. To do so, we use a similar method to that used in [13] to form a virtual forest of $\left(\geq 2\right)$-HSTs, based on the edges of the original tree.

The decomposition.

Let $T$ be the tree, with general weights, rooted at root edge $r$. We create a forest, the edges of which are the edges of $T$.

Definition 4.25** (parenthood in virtual $\left(\geq 2\right)$-HST).**

For every edge $e$, we define $p^{\prime}(e)$, the *virtual parent *of $e$, to be the least ancestor $e^{\prime}$ of $e$ in $T$ such that $w(e)\leq 2w(e^{\prime})$. If there is no such $e^{\prime}$, then $e$ is *the root edge *of a virtual tree in the forest.

We define the forest according to the function $p^{\prime}$. Observe that each connected component is indeed a tree, and specifically a $\left(\geq 2\right)$-HST. Denote by $T^{1},....,T^{m}$ the virtual trees formed from $T$, and denote by $r^{i}$ the root edge of $T^{i}$

Let $I$ be an instance of online multilevel aggregation with delay. We partition the requests of $I$ to $I^{1},...,I^{m}$, such that a request belongs to $I^{i}$ if the leaf edge $v_{q}\in I^{i}$.

We denote by $\mathrm{OPT}_{i}$ the optimal solution for the multilevel aggregation instance $I_{i}$ in the virtual tree $T_{i}$. Using an identical argument to Observation 4.2 in [13], we have the following observation.

Observation 4.26**.**

$\mathrm{OPT}\geq\sum_{i=1}^{m}\mathrm{OPT}_{i}$**

Definition 4.27**.**

Let $e\in T_{i}$. We define $B_{e}$ to be the set of edges in $T$ on the path from $e$ to $p^{\prime}(e)$ (including $e$, not including $p^{\prime}(e)$). If $e=r^{i}$, then let $B_{e}$ be all the edges from $e$ to $r$, including $r$.

Definition 4.28**.**

Let $\mathcal{T}_{i}$ be some transmittable subtree in $T_{i}$ for any $i$. We define $\bar{T}_{i}=\bigcup_{e\in\mathcal{T}_{i}}B_{e}$ to be the *concretization *of $T_{i}$.

The algorithm.

We now describe the algorithm for online multilevel aggregation with delay on a general tree. The algorithm is:

Run Algorithm 6 for each of $T_{1},....,T_{m}$ separately. 2. 2.

Whenever the instance of Algorithm 6 for $T_{i}$ transmits the virtual subtree $\mathcal{T}_{i}$, transmit its concretization $\bar{\mathcal{T}}_{i}$.

Observe that any transmission made by the main algorithm indeed serves the same requests as the original, virtual transmission. We denote by $\mathrm{ALG}_{i}$ the virtual cost of the $\left(\geq 2\right)$-HST algorithm for $T_{i}$ – that is, the delay of the requests of $I_{i}$ plus the sum of the costs of virtual transmissions triggered by the $\left(\geq 2\right)$-HST algorithm for $T_{i}$.

We denote by $k_{i}$ for $i\in[m]$ the number of transmissions caused by the algorithm for $T_{i}$. The following lemma is a restatement of Lemma 4.12.

Lemma 4.29**.**

$k_{i}w(r^{i})\leq\mathrm{OPT}_{i}^{B}+D\cdot\mathrm{OPT}_{i}^{D}\leq D\cdot\mathrm{OPT}_{i}$**

It remains to bound the cost of the algorithm.

Proposition 4.30**.**

$\mathrm{ALG}^{D}\leq\mathrm{ALG}^{B}$**

Proof.

Observe that $\mathrm{ALG}^{D}=\sum_{i=1}^{m}\mathrm{ALG}_{i}^{D}$ and that $\mathrm{ALG}^{B}\geq\sum_{i=1}^{m}\mathrm{ALG}_{i}^{B}$. Thus, we have that

[TABLE]

where the second inequality is from Lemma 4.10. ∎

We denote by $\overline{\mathrm{ALG}}_{i}^{B}=\sum_{j=1}^{k_{i}}w(\bar{\mathcal{T}}_{i}^{j})$ where $\mathcal{T}_{i}^{j}$ is the $j$’th transmission made by the $T_{i}$ algorithm. Observe that $\mathrm{ALG}^{B}=\sum_{i=1}^{m}\overline{\mathrm{ALG}}_{i}^{B}$.

The following lemma bounds the cost of the algorithm, and provides the final component for Theorem 4.2.

Lemma 4.31**.**

For every $i$, we have that $\overline{\mathrm{ALG}}_{i}^{B}\leq 2Dk_{i}\cdot w(r^{i})$.

Fix $i\in[m]$. We denote by $\mathcal{T}_{j}$ for $j\in[k_{i}]$ the $j$’th virtual transmission made by the $T_{i}$-algorithm. For $j\in[k_{i}]$, we denote by $t_{j}$ the time of $\mathcal{T}_{j}$’s transmission.

To prove Lemma 4.31, we construct a preflow, in a similar manner to the proof of Lemma 4.6. However, in this case we also have nodes that correspond to edges that for which Explore is not called.

We now describe the construction of the graph $G=(V\cup\{s\},E)$, and the weight function $\alpha$, such that $Z=(G,s,\alpha)$ is a preflow. Each vertex in $V$ is of the form $(e,j)$ where $e\in\bar{\mathcal{T}}_{j}$. To describe the edge set $E$, we require the following definition.

Definition 4.32** ($x$-route).**

Let $(e,j)$, $(e^{\prime},j^{\prime})$ be two edges such that $e$ is an ancestor of $e^{\prime}$, and $j^{\prime}\geq j$. Denote by $e=e_{0},e_{1},...,e_{l}=e^{\prime}$ the path from $e$ to $e^{\prime}$ in $T$. We define an $x$-route from $(e_{1},j_{1})$ to $(e_{2},j_{2})$ to be the set of the following charging node edges.

An edge $\sigma$ from $(e,j)$ to $(e_{1},j^{\prime})$ with $\alpha(\sigma)=x\cdot h_{e_{1}}$. 2. 2.

For each $\beta\in[l-1]$, an edge $\sigma$ from $(e_{\beta},j^{\prime})$ to $(e_{\beta+1},j^{\prime})$ with $\alpha(\sigma)=x\cdot h_{e_{\beta+1}}$.

We also define an $x$-route from $s$ to $(e^{\prime},j^{\prime})$ in a similar manner. Let $r=e_{1},e_{2},...,e_{l}=e^{\prime}$ the path from the root of $T$ to $e^{\prime}$. The edges of this $x$-route are:

An edge $\sigma$ from $s$ to $(r,j^{\prime})$ with $\alpha(\sigma)=x\cdot D$. 2. 2.

For each $\beta\in[l-1]$, and edge $\sigma$ from $(e_{\beta},j^{\prime})$ to $(e_{\beta+1},j^{\prime})$ with $\alpha(\sigma)=x\cdot h_{e_{\beta+1}}$.

We can now describe $E$. The edges of $E$ are constructed in the following way:

For each $j\in[k_{i}]$, add to $E$ the edges of a $w(r_{i})$-route from $s$ to $(r_{i},j)$. 2. 2.

For two charging nodes $(e_{1},j_{1})$, $(e_{2},j_{2})$ such that $e_{1},e_{2}\in T_{i}$, $e_{1}$ is an ancestor of $e_{2}$ and $\textnormal{{Explore}}_{t_{j_{1}}}(e_{1})$ invested $x$ in $\textnormal{{Explore}}_{t_{j_{2}}}(e_{2})$, add to $E$ the edges of an $x$-route from $(e_{1},j_{1})$ to $(e_{2},j_{2})$.

Observation 4.33**.**

For every two edges $e\in T$, $e^{\prime}\in T_{i}$ such that $e\in B_{e^{\prime}}$ it holds that $w(e)\leq 2w(e^{\prime})$.

Lemma 4.34**.**

For every charging node $\mu=(e,j)$ it holds that $\chi_{\mu}\geq\frac{w(e)}{2}$.

Proof.

Observe that $x$-routes do not

It must be that $e\in\bar{\mathcal{T}}_{j}$. Hence, there exists an edge $e^{\prime}\in\mathcal{T}_{j}$ such that $e\in B_{e^{\prime}}$. Since $e^{\prime}\in\mathcal{T}_{j}$, then we are in one of the following cases.

Case 1: $e^{\prime}=e$, and thus $e^{\prime}\in\mathcal{T}_{j}$. It can be shown that $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq w(e)\cdot h_{e}$, and that $\sum_{\sigma\in E_{\mu}^{-}}\alpha(\sigma)\leq w(e)\cdot(h_{e}-1)$, similarly to the proof of Lemma 4.11.

Case 2: $e\neq e^{\prime}$ and $e^{\prime}\neq r_{i}$. Thus, $e\notin T_{i}$. Observe that since $e\notin T_{i}$, adding any $x$-route cannot decrease $\chi_{\mu}$. Indeed, adding an $x$-route can only create an outgoing edge from $\mu$ when creating an incoming edge with greater $\alpha$. Thus, we locate a set of $x$-routes that increases $\chi_{\mu}$ to at least $w(e^{\prime})$. From Observation 4.33, we get that $w(e^{\prime})\geq\frac{w(e)}{2}$, proving the lemma.

If $e^{\prime}=r_{i}$, then a $w(r_{i})$-route is created from $s$ to $(r_{i},j)$. Since $e$ is on the path from $r$ to $r_{i}$, it must be that the route adds:

• •

An incoming edge $\sigma$ to $(e,j)$ with $\alpha(\sigma)\geq h_{e}\cdot w(r_{i})$.

• •

An outgoing edge $\sigma^{-}$ from $(e,j)$ with $\alpha(\sigma)\leq(h_{e}-1)\cdot w(r_{i})$.

showing that $\chi_{\mu}\geq w(r_{i})\geq\frac{w(e)}{2}$.

Otherwise, $e^{\prime}\neq r_{i}$. Observe that any $x$-route to $(e^{\prime},j)$ contains $\mu$, and increases $\chi_{\mu}$ by at least $x$ (using the same argument as the case for $e^{\prime}=r_{i}$). In this case, observe that a total of $w(e^{\prime})$ has been invested has been invested in $(e^{\prime},j)$ to trigger $\textnormal{{Explore}}_{t_{j}}(e^{\prime})$. This completes the proof. ∎

Proof of Lemma 4.31.

We have that $\overline{\mathrm{ALG}}_{i}^{B}\leq 2Dk_{i}\cdot w(r_{i})$.

Observe the preflow $Z$ as constructed. We have that $\omega_{Z}=Dk_{i}w(r_{i})$. From Lemma 4.34, and using Proposition 2.18, we have

[TABLE]

∎

Proof of Theorem 4.2.

From Lemmas 4.29 and 4.31, we have that for every $i\in[m]$

[TABLE]

From Observation 4.26, we have that

[TABLE]

Using Lemma 4.30, we have that

[TABLE]

as required. ∎

5 Online Service with Delay

5.1 Problem and Notation

In the online service with delay (OSD) problem, a single server exists on a point in a metric space. Requests arrive on points of the metric space over time, and accumulate delay until served, where serving a request requires moving the server to that request. The cost of moving the server from one point to another is the distance between those two points in the metric space. The goal is to minimize the sum of the moving cost and the delay cost.

Formally, a request is a tuple $q=(v_{q},r_{q},d_{q}(t))$ such that $v_{q}$ is the point on which $q$ arrives, the request arrives at time $r_{q}$, and $d_{q}(t)$ is an arbitrary non-decreasing continuous delay function. We also assume that $d_{q}(t)$ tends infinity as time progresses. For any instance of OSD $I$, denote by $\mathrm{ALG}^{B}$ the total cost of moving the algorithm’s server. We also denote by $\mathrm{ALG}^{D}=\sum_{q\in Q}d_{q}(t_{q})$, where $t_{q}$ is the time in which the request $q$ is served. Then the algorithm’s goal is to minimize the total cost

[TABLE]

As in the previous problems in this paper, we also consider the special case in which the metric space is the leaves of a $\left(\geq 2\right)$-HST. Without loss of generality, we allow an algorithm to move its server to the internal nodes of the tree, even though they are not a part of the original metric space. This is implemented by lazy moving of the server – that is, the server never really moves to those internal nodes, but its virtual location in an internal node is kept in the algorithm’s memory for the sake of calculations.

In this section, we prove the following theorem.

Theorem 5.1**.**

There exists a randomized $O(\log^{2}n)$-competitive algorithm for online service with delay on a general metric space of $n$ points.

5.2 Algorithm for HSTs

In this subsection, we present an algorithm for online service with delay on $\left(\geq 2\right)$-HSTs. We assume that the weight of each edge is a power of $2$ – this can be enforced, at a loss factor of $2$ to competitiveness. This algorithm encapsulates our algorithm for online multilevel aggregation with delay, while using similar mechanisms to those in [5].

For an edge $e$, denote $\mathcal{C}(e)=\{e^{\prime}|p(e^{\prime})=p(e)\wedge w(e^{\prime})<w(e)\}$, the set of sibling edges of $e$ with smaller weight. Note that for every $e^{\prime}\in\mathcal{C}(e)$ we have $w(e^{\prime})\leq\frac{1}{2}w(e)$, since edge weights are powers of 2. We define the following.

Definition 5.2** (Top and bottom nodes).**

For an edge $e$, we define $v_{e}^{\top}$ to be the top node of $e$, and $v_{e}^{\bot}$ to be the bottom node of $e$.

Definition 5.3** (Relative subtree $R_{e}$).**

For an edge $e$, we define the relative subtree of $e$ to be $\{e\}\cup\bigcup_{e^{\prime}\in\mathcal{C}(e)}T_{e^{\prime}}$.

The following definition is required for defining exactly what we mean when referring to locations of servers and requests.

Definition 5.4** (Locations of servers and requests).**

Consider the location of a server (either the algorithm’s or the optimum’s).

• •

For $T_{e}$, we say that *the server is internal to $T_{e}$ *if the server is in one of the nodes of $T_{e}$ other than $v_{e}^{\top}$.

• •

For $R_{e}=\{e\}\cup\left(\bigcup_{e^{\prime}\in\mathcal{C}(e)}T_{e^{\prime}}\right)$, we say that *the server is internal to $R_{e}$ *if the server in one of the nodes of $R_{e}$ other than $v_{e}^{\bot}$.

The same applies for saying that a request $q$ is internal to $T_{e}$ (or $R_{e}$), and writing $q\in T_{e}$ (or $q\in R_{e}$).

Let $Q\subseteq R_{e}$ be a set of requests, and denote by $Q\restriction_{T_{e^{\prime}}}=\{q\in T_{e^{\prime}}|q\in Q\}$. Then we define $R_{e}^{Q}$ to be

[TABLE]

We sometimes write $Y_{e}$ to make claims that refer to either $R_{e}$ or $T_{e}$.

Definition 5.5** (Saturation).**

We say that a set of requests $Q\subseteq Y_{e}$ saturates $Y_{e}$ at time $t$ if $d_{Q}(t)\geq w(Y_{e}^{Q})$.

Definition 5.6** (Major edges).**

We say that an edge $e$ is *major *at a time $t$ if every edge $e^{\prime}$ on the path from the algorithm’s server to $e$ has that $w(e^{\prime})\leq w(e)$.

Definition 5.7** (Critical set).**

We say that a set of requests $Q$ is *critical *at time $t$ if it saturates $Y_{e}$ at time $t$ for an edge $e$ which is major at time $t$.

Definition 5.8**.**

Let $e$ be an edge, and $Y_{e}$ be either $T_{e}$ or $R_{e}$. We say that the algorithm’s server is *on the other side of $e$ than $Y_{e}$ *if:

• •

The server is internal to $T_{e}$ and $Y_{e}=R_{e}$.

• •

The server is not internal to $T_{e}$ and $Y_{e}=T_{e}$.

The following proposition allows us to assume that whenever a set of requests is critical by saturating $Y_{e}$ for a major edge $e$, we have that the algorithm’s server is on the other side of $e$ than $Y_{e}$.

Proposition 5.9**.**

Suppose there exists a critical set of requests $Q$, saturating $Y_{e}$ for $e$ a major edge, at some point in time. Then there exists another critical set of requests $Q^{\prime}$, saturating $Y_{e^{\prime}}$ for another major edge $e^{\prime}$, such that the algorithm’s server is on the other side of $e^{\prime}$ than $Y_{e^{\prime}}$.

Proof.

If the server is on the other side of $e$ than $Y_{e}$, we are done. Suppose otherwise, and let $Q$ be the minimal set saturating $Y_{e}$.

Consider the case that $Y_{e}=T_{e}$, and the algorithm’s server is internal to $T_{e}$. Note that $e$ cannot be a leaf edge – otherwise, the server and all requests in $Q$ must be on $v_{e}^{\bot}$, in contradiction to the requests of $Q$ being pending.

If the server is in $v_{e}^{\bot}$, we can thus choose $e^{\prime}$ to be any child edge of $e$ saturated by $Q\restriction_{T_{e^{\prime}}}$(such an edge must exist, otherwise $Q$ would not have saturated $T_{e}$). 2. 2.

If the server is internal to $T_{\hat{e}}$ for some $\hat{e}$ child edge of $e$, then:

1. (a)

If there exists a sibling $\tilde{e}$ of $\hat{e}$ such that $w(\tilde{e})\geq w(\hat{e})$ such that $Q\restriction_{T_{\tilde{e}}}$ is saturated, then $\tilde{e}$ is major, and thus $Q\restriction_{T_{\tilde{e}}}$ is critical. The server is on the other side of $\tilde{e}$ than $T_{\tilde{e}}$, completing the proof. 2. (b)

If there is no such $\tilde{e}$, by the minimality of $Q$ we have for any $\tilde{e}$ sibling of $\hat{e}$ such that $w(\tilde{e})\geq w(e)$ that $Q\restriction_{T_{\tilde{e}}}=\emptyset$.

1. i.

If $Q\restriction_{T_{\hat{e}}}$ does not saturate $T_{\hat{e}}$, then again from minimality of $Q$ we have $Q\restriction_{T_{\hat{e}}}=\emptyset$. Thus $Q\subseteq R_{\hat{e}}$. Since $w(R_{\hat{e}}^{Q})=w(T_{e}^{Q})-w(e)+w(\hat{e})\leq w(T_{e}^{Q})$, it holds that $Q$ saturates $\hat{e}$, and is thus critical. 2. ii.

Otherwise, $Q\restriction_{T_{\hat{e}}}$ saturates $T_{\hat{e}}$, and is thus critical. Since the server is internal to $T_{\hat{e}}$, induction on the height of $e$ yields the proof.

The case that $Y_{e}=R_{e}$ and the server is not internal to $T_{e}$ is very similar. ∎

**Algorithm’s description. **The algorithm for service with delay on a $\left(\geq 2\right)$-HST is given in Algorithm 9. The algorithm triggers a service whenever a set of requests becomes critical. We assume that the set of requests considered by the algorithm is always on the other side of the major edge than the server. This assumption uses Proposition 5.9.

Whenever a set of requests becomes critical, saturating $Y_{e}$ for a major edge $e$, the algorithm moves the server to the closer node touching $e$ (denoted by $u_{1}$). It then calls the exploration function of the multilevel aggregation algorithm for $\left(\geq 2\right)$-HSTs, given in Algorithm 6. To make this well defined, a call to $\texttt{MultilevelAggregationExplore}(Y_{e})$ observes the $\left(\geq 2\right)$-HST $Y_{e}$, in which $e$ is the root edge. If $Y_{e}=R_{e}$, then $e$ is “promoted” to be the parent edge of its siblings in $R_{e}$ for the sake of the multilevel aggregation exploration (note that the resulting tree is indeed a $\left(\geq 2\right)$-HST). The counters used by the exploration are the same counters $c_{e}$ of the service with delay algorithm.

The exploration of the multilevel aggregation algorithm yields a tree to transmit $\mathcal{T}$. In the case of service with delay, instead of transmitting $\mathcal{T}$, we traverse it with the server, in DFS order, returning to the node $u_{1}$. Note that the cost of this is exactly twice the weight of $\mathcal{T}$. To conclude, the server crosses $e$, ending the service on the other side of $e$ than before the service. Observe that while this concludes the call to UponCritical, it may immediately trigger new calls to UponCritical due to new edges becoming major in the server’s new location.

5.3 Analysis

Fix any instance of online service with delay on the tree $T$. Define $\mathrm{ALG}^{B}$ and $\mathrm{ALG}^{D}$ to be the total moving cost and the total delay cost of the algorithm on the instance, respectively. Define $\mathrm{ALG}=\mathrm{ALG}^{B}+\mathrm{ALG}^{D}$. Define $\mathrm{OPT}^{B},\mathrm{OPT}^{D}$ and $\mathrm{OPT}$ similarly for the optimum.

In this subsection, we prove the following theorem.

Theorem 5.10**.**

$\mathrm{ALG}\leq O(D)\cdot\mathrm{OPT}^{B}+O(D^{2})\cdot\mathrm{OPT}^{D}$.

Observe that upon embedding from a general metric space of $n$ points to a $\left(\geq 2\right)$-HST, the moving cost is distorted but the delay cost is not. Thus, using similar arguments to the proof of Theorem 2.3, we have that Theorem 5.10 implies Theorem 5.1 for general metric spaces.

5.3.1 Upper Bounding $\mathrm{ALG}$

We again denote by $k$ the number of services made by the algorithm. That is, $k$ is the number of calls to UponCritical. We denote by $e_{i}$ for $i\in[k]$ the major edge considered in the $i$’th service. We also denote by $t_{i}$ the time of the $i$’th service.

We devote this part of the analysis to proving the following lemma.

Lemma 5.11**.**

$\mathrm{ALG}\leq O(D)\cdot\sum_{i=1}^{k}w(e_{i})$**

Observe the operation of the algorithm. Upon a critical set of requests the algorithm calls UponCritical a few times consecutively, until there is no critical set of requests with regard to the server’s current location. The algorithm then enters the waiting state. We call each such instantaneous set of services a *service phase. *We denote by $k^{\prime}$ the number of these phases. We also assume that no two sets of requests become critical at the same time, which can easily be enforced by the algorithm by breaking ties arbitrarily.

Proposition 5.12**.**

Consider the service phase which starts from a set of requests $Q$ becoming critical by saturating $Y_{e}$, for a major edge $e$. Then during the entire phase, the server only serves requests internal to $Y_{e}$.

Proof.

The first service in the phase only serves requests internal to $Y_{e}$, and the server finishes the service in a point internal to $Y_{e}$. We claim that during the rest of the phase, the server remains internal to $Y_{e}$, which proves the proposition.

Assume otherwise. Then we must have that at some point during the phase, a set of pending requests $Q^{\prime}$ is critical (with regards to the server’s location at that point in the phase) by saturating $Y_{e^{\prime}}$ for an edge $e^{\prime}\notin Y_{e}$. Consider the first such point during the phase. Due to our assumption that no two sets of requests become critical at the same time, we have that $e^{\prime}$ must not have been a major edge before the start of the phase. But note that all edges in $Y_{e}$ have weight at most $w(e)$, and thus the server only traversed edges of weight at most $w(e)$ since the start of the phase. Thus, we must have that $w(e^{\prime})<w(e)$. Now, note that the server cannot reach any edge $e^{\prime}$ such that $w(e^{\prime})<w(e)$ and $e^{\prime}\notin Y_{e}$ from a position which is internal to $Y_{e}$ without traversing an edge of weight at least $w(e)$. This is a contradiction to $e^{\prime}$ being a major edge. ∎

Lemma 5.13**.**

$\mathrm{ALG}^{D}\leq\mathrm{ALG}^{B}$**

Proof.

Let $\mathcal{Q}$ be the set of all requests in the instance. Divide $\mathcal{Q}$ into $Q_{1},...,Q_{k^{\prime}}$ such that $Q_{i}$ are the requests served by the algorithm in the $i$’th phase.

Fix the $i$’th phase, let $t$ be the time of the phase and let $Q=Q_{i}$. Let $Y_{e}$ be the saturated tree triggering the phase, with $e$ a major edge. Due to Proposition 5.12, we have that $Q\subseteq Y_{e}$. Since the algorithm’s server is outside $Y_{e}$, we have that $w(Y_{e}^{Q})$ is a lower bound for the cost of moving the server to serve $Q$. Since $e$ is a major edge immediately before the start of the phase, we have that $d_{Q}(t)\leq w(Y_{e}^{Q})$. Thus the delay incurred by the requests of $Q$ is bounded by the buying cost incurred by the algorithm in the phase.

Summing this conclusion over all phases yields the lemma. ∎

Proposition 5.14**.**

Moving the server to touch a major edge $e$ costs at most $2w(e)$.

Proof.

Since we are in a $\left(\geq 2\right)$-HST, the path from any node to another node consists of (at most) one upwards path followed by one downwards path. Since $e$ is a major edge, each edge on the path from the server to $e$ must have weight at most $w(e)$. Thus, the downwards path must be of length [math] – otherwise, it would contain $e$’s parent edge, which has weight larger than $w(e)$. Consider that the weight of the upwards path is at most $2w(e)$. ∎

Lemma 5.15**.**

$\mathrm{ALG}^{B}\leq(2D+5)\cdot\sum_{i=1}^{k}w(e_{i})$**

Proof.

Each service triggered by the saturation of a major edge $e$ causes a multilevel aggregation service of either $T_{e}$ or $R_{e}$, plus additional server movements required to reach and traverse $e$. The additional movements are of at most $3w(e)$ (using Proposition 5.14), and thus $3\cdot\sum_{i=1}^{k}w(e_{i})$ over all services.

Using a very similar proof to the case for multilevel aggregation, we can show that the sum of the weight of the trees to “transmit” yielded by the calls to the multilevel aggregation algorithm are at most $(D+1)\sum_{i=1}^{k}w(e_{i})$. Since traversing a tree by DFS is twice the cost of transmission, the buying cost incurred by the OSD algorithm for that step is at most $2(D+1)\sum_{i=1}^{k}w(e_{i})$.

Overall, the buying cost of the algorithm is at most $(2D+5)\sum_{i=1}^{k}w(e_{i})$. ∎

of Lemma 5.11.

The lemma results directly from Lemmas 5.13 and 5.15. ∎

5.3.2 Lower Bounding $\mathrm{OPT}$

Definition 5.16** ($\mathbb{I}_{i}$).**

We define the indicator variable $\mathbb{I}_{i}$ for $i\in[k]$ to be $1$ if the optimum’s server was on the same side of $e_{i}$ at $t_{i}$ as the algorithm’s server (before the call to UponCritical), and [math] otherwise.

The following lemma provides a lower bound on the cost of the optimum.

Lemma 5.17**.**

$\sum_{i=1}^{k}\mathbb{I}_{i}\cdot w(e_{i})\leq 3\cdot\mathrm{OPT}^{B}+3D\cdot\mathrm{OPT}^{D}$**

Charging nodes and incurred costs.

We first define the charging nodes for the analysis of this algorithm. For every edge $e$, there exist three types of charging nodes:

Standard root charging nodes (SRCN), which are nodes of the form $(e,[\tau_{1},\tau_{2}))$ where $\tau_{1}$ and $\tau_{2}$ are two subsequent times in which $\textnormal{{Explore}}(e)$ is called due to $e$ being a major edge and $T_{e}$ being saturated, triggering service. 2. 2.

Relative root charging nodes (RRCN), which are nodes of the form $(e,[\tau_{1},\tau_{2}))$ where $\tau_{1}$ and $\tau_{2}$ are two subsequent times in which $\textnormal{{Explore}}(e)$ is called due to $e$ being a major edge and $R_{e}$ being saturated, triggering service. 3. 3.

Normal charging nodes (NCN), which are nodes of the form $(e,[\tau_{1},\tau_{2}))$ where $\tau_{1}$ and $\tau_{2}$ are two subsequent times in which $\textnormal{{Explore}}(e)$ is called due to the counter $c_{e}$* *reaching $w(e)$.

Nodes of types 1 and 2 correspond to root charging nodes in the multilevel aggregation case, while nodes of type 3 correspond to non-root nodes.

For a charging node $\mu=(e,[\tau_{1},\tau_{2}))$ we say that:

• •

$\mathrm{OPT}$ incurs a *buying cost *of $w(e)$ in $\mu$ if $\mathrm{OPT}$ traversed the edge $e$ during $[\tau_{1},\tau_{2})$. We denote the buying cost that $\mathrm{OPT}$ incurs in $\mu$ by $c_{b}(\mu)$.

• •

If $\mu$ is an SRCN or an NCN, $\mathrm{OPT}$ incurs a delay cost in $\mu$ equal to the delay incurred by $\mathrm{OPT}$ on the set of requests $Q=\{q\in T_{e}|r_{q}\in[\tau_{1},\tau_{2})\}$

• •

If $\mu$ is an RRCN, $\mathrm{OPT}$ incurs a* delay cost* in $\mu$ equal to the delay incurred by $\mathrm{OPT}$ on the set of requests $Q=\{q\in R_{e}|r_{q}\in[\tau_{1},\tau_{2})\}$ if $\mathrm{OPT}$’s server remained internal to $T_{e}$ during $[\tau_{1},\tau_{2})$.

We denote the total delay cost incurred by $\mathrm{OPT}$ in $\mu$ be $c_{d}(\mu)$. We denote the total cost that $\mathrm{OPT}$ incurs in $\mu$ by $c(\mu)=c_{b}(\mu)+c_{d}(\mu)$.

Lemma 5.18**.**

$\sum_{\mu\in M}c(\mu)\geq 3\cdot\mathrm{OPT}^{B}+3D\cdot\mathrm{OPT}^{D}$**

Proof.

Observe that any edge traversal by the optimum’s server can be counted in three charging nodes relating to that edge (one SRCN, one RRCN and one NCN).

Any delay cost incurred by the optimum due to a request $q$ can be counted in NCNs and SRCNs along the depth of the tree, yielding $2D$ such charging nodes. In addition, the delay of $q$ can be counted in at most $D$ RRCNs along the path from the root to the location of the optimum’s server at time $r_{q}$.

These observations yield the lemma. ∎

Denote by $M$ the set of all charging nodes. To prove Lemma 4.12, we show a preflow on the set of vertices $M\cup\{s\}$, where $s$ is the source node.

The following definition of charging node investment is nearly identical to the definition in the multilevel aggregation case.

Definition 5.19** (Investing).**

For a charging node $\mu_{1}=(e_{1},[\tau_{1}^{1},\tau_{2}^{1}))$ and an NCN $\mu_{2}=(e_{2},[\tau_{1}^{2},\tau_{2}^{2}))$, we say that $\mu_{1}$ *invested $x$ in $\mu_{2}$ *if $\textnormal{{Explore}}_{\tau_{1}^{1}}(e_{1})$ raised the counter $c_{e_{2}}$ by $x$ during the counter phase $[\tau_{1}^{2},\tau_{2}^{2})$ (not including recursive calls made by $\textnormal{{Explore}}_{\tau_{1}^{1}}(e_{1})$).

Procedure 10 is used to build the preflow. As in the previous analyses, we define $\bar{E}$ to be the set of possible edges between nodes of $M$ to themselves. As before, an edge $\sigma$ exists in $\bar{E}$ from a charging node $\mu$ to a charging node $\mu^{\prime}$ if $\mu$ invested in $\mu^{\prime}$, and $\alpha(\sigma)$ is set to be the total invested amount.

We use the following definition for ease.

Definition 5.20** ($Y_{\mu}$).**

For a charging node $\mu=(e,[\tau_{1},\tau_{2}))$, we define $Y_{\mu}$ to be $R_{e}$ if $\mu$ is a RRCN. Otherwise, we define $Y_{\mu}$ to be $T_{e}$.

Observation 5.21**.**

If a node $\mu=(e,[\tau_{1},\tau_{2}))$ invested in a node $\mu^{\prime}=(e^{\prime},[\tau_{1},\tau_{2}))$, then $Y_{\mu^{\prime}}\subseteq Y_{\mu}$.

Proposition 5.22** (analogue of Proposition 4.21).**

Let $\mu=(e,[\tau_{1},\tau_{2}))$ such that $\texttt{Color}[\mu]=\mu^{\star}$ for some charging node $\mu^{\star}=(e^{\star},[\tau_{1}^{\star},\tau_{2}^{\star}))$. Then $\mathrm{OPT}$ did not enter $Y_{\mu}$ during $[\tau_{1},\tau_{2}^{\star})$.

Proof.

Since $\texttt{Color}[\mu]=\mu^{\star}$, we must have that for the RCN $\mu^{\star}$ we have that $\texttt{Color}[\mu^{\star}]=\mu^{\star}$. Thus, we have that $\mathbb{I}_{i}=1$ for $i$ such that $\tau_{2}^{\star}=t_{i}$, and thus the optimum’s server was on the same side of $e^{\star}$ as the algorithm’s server before the service at $\tau_{2}^{\star}$. Since we only consider critical trees on the other side of the major edge, we have that the optimum’s server was not internal to $Y_{\mu^{\star}}$ at time $\tau_{2}^{\star}$. Since $\texttt{Color}[\mu^{\star}]\neq\texttt{Special}$, the optimum’s server did not traverse $e^{\star}$ during $[\tau_{1}^{\star},\tau_{2}^{\star})$, and thus was not internal to $Y_{\mu^{\star}}$ during $[\tau_{1}^{\star},\tau_{2}^{\star})$.

What follows is a similar inductive argument to that of Proposition 2.23. For the base case that $\mu=\mu^{\star}$, we are done. We now prove the proposition by induction on the depth of the propagation of the color $\mu^{\star}$ to $\mu$. Observe that the color $\mu^{\star}$ was propagated to $\mu$ from another charging node $\mu^{\prime}=(e^{\prime},[\tau_{1}^{\prime},\tau_{2}^{\prime}))$. By induction, the optimum’s server was not internal to $Y_{\mu^{\prime}}$ during $[\tau_{1}^{\prime},\tau_{2}^{\star})$. From Observation 5.21, we have that the optimum’s server was not internal to $Y_{\mu}$ during $[\tau_{1}^{\prime},\tau_{2}^{\star})$.

Since $\texttt{Color}[\mu]\neq\texttt{Special}$, the optimum’s server did not traverse $e$ during $[\tau_{1},\tau_{2})$. Since $\mu^{\prime}$ invested in $\mu$, we have that $\tau_{1}^{\prime}\leq\tau_{2}$, and thus the optimum’s server was not internal to $Y_{\mu}$ during $[\tau_{1},\tau_{2}^{\star})$ as required. ∎

Observation 5.23**.**

Corollary 4.19 from the multilevel aggregation case holds in this case as well. That is, if $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq w(e)$, then $\chi_{\mu}\geq 0$.

Lemma 5.24**.**

The preflow defined by Procedure 10 is valid.

Proof.

As in previous versions of this lemma, we need to show that $\chi_{\mu}\geq 0$ for every $\mu\in M$. We separate according to cases.

Case 1: $\texttt{Color}[\mu]=\texttt{Special}$. In this case, $\mathrm{OPT}$ incurs a buying cost of $w(e)$ at $\mu$, completing the case according to Observation 5.23.

Case 2: $\texttt{Color}[\mu]=\mu^{\star}$ for some charging node $\mu^{\star}$. In this case, observe that Observation 4.20 applies for OSD as well. Thus, $\mu$ has invested in other nodes a total of exactly $w(e)$, and thus $\sum_{\sigma\in E_{\mu}^{+}}\alpha(\sigma)\geq w(e)$. Observation 5.23 completes the proof for this case.

Case 3: $\texttt{Color}[\mu]=\texttt{None}$. If there are no outgoing edges from $\mu$, then clearly $\chi_{\mu}\geq 0$ and we are done. Otherwise, $\mu$ is an NCN, and there exists an outgoing edge $\sigma$ to some node $\mu^{\prime}=(e^{\prime},[\tau_{1}^{\prime},\tau_{2}^{\prime}))$ with $\texttt{Color}[\mu^{\prime}]=\mu^{\star}$ for some charging node $\mu^{\star}=(e^{\star},[\tau_{1}^{\star},\tau_{2}^{\star}))$. Observe that since $\mu^{\prime}$ invested in $\mu$, we must have that $\tau_{1}^{\prime}\leq\tau_{2}$. Using Proposition 5.22, and the fact that $\texttt{Bought}[\mu]=False$, we have that $\mathrm{OPT}$ was not internal to $Y_{\mu}$ during $[\tau_{1},\tau_{2}^{\star})$. As in Case 3 of Lemma 4.22, we locate a set of requests internal to $Y_{\mu}$ due to which $\mathrm{OPT}$ incurs delay cost of $w(e)$ in $\mu$.

**Claim – **There exists a set of requests $Q^{\prime}\subseteq Y_{\mu}$ such that $r_{q}\in[\tau_{1},\tau_{2})$ such that $d_{Q^{\prime}}(\tau_{2}^{\star})\geq w(e)$.

Proof of claim.

Identical to the proof for the corresponding claim in the multilevel aggregation analysis. ∎

Using the claim, observe that since the optimum’s server was not internal to $Y_{\mu}$ during $[\tau_{1},\tau_{2}^{\star})$, it has incurred $w(e)$ delay due to the requests of $Q^{\prime}$. Due to the definition of delay cost on an NCN, we have that $c_{d}(\mu)\geq w(e)$. This completes the analysis of the case due to Observation 5.23. ∎

Lemma 5.25**.**

For every root charging node $\mu=(e_{i},[t_{i-1},t_{i}))$ we have that $\chi_{\mu}\geq\mathbb{I}_{i}\cdot w(e_{i})$.

Proof.

If $\texttt{Color}[\mu]\neq\texttt{None}$, we have that $\chi_{\mu}\geq w(e_{i})$ using identical arguments to Cases 1 and 2 of Lemma 5.24.

Otherwise, $\texttt{Color}[\mu]=None.$ Observe that $\chi_{\mu}\geq 0$, due to Lemma 5.24, which covers the case that $\mathbb{I}_{i}=0$. Now, suppose that $\mathbb{I}_{i}=1$. We show that $\mathrm{OPT}$ incurred a delay cost of at least $w(e_{i})$ in $\mu$.

**Claim – **There exists a set of requests $Q^{\prime}\subseteq Y_{\mu}$ such that $r_{q}\in[t_{i-1},t_{i})$ such that $d_{Q^{\prime}}(t_{i})\geq w(e)$.

Proof of Claim.

We denote by $Q$ the set of requests that became critical at $t_{i}$, triggering the service. Observe that $d_{Q}(t_{i})\geq w(Y_{\mu})$, and that $r_{q}<t_{i}$ for every $q\in Q$. Since $\texttt{Color}[\mu]=\texttt{None}$, we must have that either $t_{i-1}=-\infty$ or $\lambda_{\mu}>t_{i}$.

If $t_{i-1}=-\infty$, then $r_{q}\in[t_{i-1},t_{i})$ and choosing $Q^{\prime}=Q$ yields the claim. Otherwise, $t_{i-1}\neq-\infty$, and $\lambda_{\mu}>t_{i}$. In this case, we choose $\hat{Q}\subseteq Q$ to be the set of pending requests immediately after the service at $t_{i-1}$. Since $\lambda_{\mu}>t_{i}$, $d_{\hat{Q}}(t_{i})\leq w(Y_{\mu}^{\hat{Q}})-w(e_{i})\leq w(Y_{\mu}^{Q})-w(e_{i})$. Thus, we have that $d_{Q\backslash\hat{Q}}(t_{i})\geq w(e_{i})$. Observe that $r_{q}\geq t_{i-1}$ for every $q\in Q\backslash\hat{Q}$, and thus $r_{q}\in[t_{i-1},t_{i})$ for every $q\in Q\backslash\hat{Q}$. Thus choosing $Q^{\prime}=Q\backslash\hat{Q}$ yields the claim. ∎

We now use this claim. Observe that the optimum’s server was not internal to $Y_{\mu}$ at $t_{i}$ (due to $\mathbb{I}_{i}=1$), and since $\texttt{Color}[\mu]\neq\texttt{Special}$, the optimum’s server was not internal to $Y_{\mu}$ during $[t_{i-1},t_{i})$. Thus, the optimum incurs a delay cost of $w(e_{i})$ due to $Q^{\prime}$. Now observe that:

• •

If $\mu$ is an SRCN, then $c_{d}(\mu)\geq w(e_{i})$.

• •

If $\mu$ is an RRCN, then the algorithm’s server was internal to $T_{e_{i}}$ at time $t_{i}$. Since $\mathbb{I}_{i}=1$, the optimum’s server was internal to $T_{e_{i}}$ as well at $t_{i}$. Since $\texttt{Color}[\mu]\neq\texttt{Special}$, the optimum’s server stayed internal to $T_{e_{i}}$ during $[t_{i-1},t_{i})$. Thus, $c_{d}(\mu)\geq w(e_{i})$.

In both cases, $c_{d}(\mu)\geq w(e_{i})$, completing the proof of the case and lemma. ∎

of Lemma 5.17.

The proof of the lemma results from observing the subset $N\subseteq M$ of all root charging nodes. Lemma 5.25 implies that $\sum_{\mu\in N}\chi_{\mu}\geq\sum_{i=1}^{k}\mathbb{I}_{i}\cdot w(e_{i})$.

We now use Proposition 2.18 and Lemma 5.18 to obtain

[TABLE]

proving the lemma. ∎

5.3.3 Proof of Main Theorem

In this part of the analysis, we prove Theorem 5.10.

From Lemma 5.11, we have that $\mathrm{ALG}\leq\gamma D\cdot\sum_{i=1}^{k}w(e_{i})$ for some constant $\gamma$.

Definition 5.26** (Potential function $\phi(t)$).**

We define the potential function $\phi(t)$ to be $\gamma D$ times the distance between the algorithm’s server and the optimum’s server at time $t$.

Observe that $\phi(-\infty)=0$.

For every $i\in[k]$, define the difference in potential $\Delta_{i}\phi=\phi(t_{i}^{+})-\phi(t_{i}^{-})$, where $t_{i}^{-}$ is time $t_{i}$ immediately before the $i$’th service and $t_{i}^{+}$ is time $t_{i}$ immediately after the $i$’th service.

We define $\mathrm{ALG}_{i}=\gamma Dw(e_{i})$, and $\mathrm{OPT}_{i}=\mathbb{I}_{i}\cdot w(e_{i})$. Observe from Lemmas 5.11 and 5.17 that $\sum_{i}\mathrm{ALG}_{i}\geq\mathrm{ALG}$ and $\sum_{i}\mathrm{OPT}_{i}\leq 3\cdot\mathrm{OPT}^{B}+3D\cdot\mathrm{OPT}^{D}$.

Lemma 5.27**.**

For every $i\in[k]$, we have that $\mathrm{ALG}_{i}\leq 4\gamma D\cdot\mathrm{OPT}_{i}-\Delta_{i}\phi$.

Proof.

If $\mathbb{I}_{i}=1$, then $\mathrm{OPT}_{i}=w(e_{i})$. Using Proposition 5.14, we have that $\Delta_{i}\phi\leq 3\gamma D\cdot w(e_{i})$. Thus

[TABLE]

as required.

Otherwise, $\mathbb{I}_{i}=0$. Then, $\mathrm{OPT}_{i}=0$. Since the optimum’s server is on the other side of the edge $e_{i}$ than the algorithm’s server before the $i$’th service, and the algorithm finishes the service on that other side of $e_{i}$, it must be that $\Delta_{i}\phi\leq-\gamma D\cdot w(e_{i})$. Thus,

[TABLE]

finishing the proof of the lemma. ∎

Proposition 5.28**.**

Denote the final value of $\phi$ by $\phi(\infty)$. Then

[TABLE]

Proof.

Consider that $\phi(\infty)=\phi(\infty)-\phi(-\infty)$ can be constructed by summing the changes to the potential function caused by moves of the algorithm’s server (which are the $\Delta_{i}\phi$) and changes caused by moves of the optimum’s server. Note that moving the optimum’s server by $x$ can increase $\phi$ by at most $\gamma Dx$. Thus,

[TABLE]

yielding the proposition. ∎

Corollary 5.29**.**

$\sum_{i}\Delta_{i}\phi\geq-\gamma D\cdot\mathrm{OPT}^{B}$**

of Theorem 5.10.

Due to Lemma 5.27, we have that

[TABLE]

Since $\sum_{i}\mathrm{OPT}_{i}\leq 3\mathrm{OPT}^{B}+3D\cdot\mathrm{OPT}^{D}$, and using Corollary 5.29, we have that

[TABLE]

proving the theorem. ∎

Appendix A Additional Figures