Replica Placement on Bounded Treewidth Graphs

TL;DR

This paper studies the replica placement problem on graphs with bounded treewidth, providing an approximation algorithm whose performance depends linearly on the treewidth, improving understanding of the problem's complexity.

Contribution

It introduces an O(t)-approximation algorithm for the replica placement problem on graphs with treewidth t, advancing approximation techniques for this class of graphs.

Findings

The problem is NP-hard to approximate within o(log n).

An O(t)-approximation algorithm is developed for graphs with treewidth t.

The approximation ratio scales linearly with the treewidth t.

Abstract

We consider the replica placement problem: given a graph with clients and nodes, place replicas on a minimum set of nodes to serve all the clients; each client is associated with a request and maximum distance that it can travel to get served and there is a maximum limit (capacity) on the amount of request a replica can serve. The problem falls under the general framework of capacitated set covering. It admits an O(\log n)-approximation and it is NP-hard to approximate within a factor of $o(\log n)$. We study the problem in terms of the treewidth $t$ of the graph and present an O(t)-approximation algorithm.

Figures

Equations

$$\min$$

$$y(a)+\sum _{u\in \mathcal{V}:a\sim u}x(a,u)$$

$$\sum _{a\in \mathcal{A}:a\sim u}x(a,u)\cdot r(a)$$

$$x(a,u)$$

$$0\le y(u),y(a)$$

$$\sum _{a\sim u}\sum _{v:a\sim v\wedge v\in \mathsf{PO}}x(a,v)$$

$$|\mathcal{B}|\le 1+|\mathtt{Red}|+\lceil \mathrm{cost}(\sigma )/\alpha \rceil \le 2+|\mathtt{Red}|+\mathrm{cost}(\sigma )/\alpha .$$

$$\mathtt{load}(A_i,C^{\prime })$$

$$\mathtt{pushable}(u_i,v_i)=\sum _{a\in A_i:a\sim v_i}x(a,u_i)r(a)\ge (1/4)\sum _{a\in A_i:a\sim v_i}r(a)=(1/4)r(A_i,v_i).$$

Full text

1 Introduction

We study a form of capacitated set cover problem **[5]** called replica placement (${\sf RP}$) that finds applications in settings such as data distribution by internet service providers (ISPs) and video on demand service delivery (e.g., **[6, 8]**). In this problem, we are given a graph representing a network of servers and a set of clients. The clients are connected to the network by attaching each client to a specific server. The clients need access to a database. We wish to serve the clients by placing replicas (copies) of the database on a selected set of servers and clients. While the selected clients get served by the dedicated replicas (i.e., cached copies) placed on themselves, we serve the other clients by assigning them to the replicas on the servers. The assignments must be done taking into account Quality of Service (QoS) and capacity constraints. The QoS constraint stipulates a maximum distance between each client and the replica serving it. The clients may have different demands (the volume of database requests they make) and the capacity constraint specifies the maximum demand that a replica can handle. The objective is to minimize the number of replicas opened. The problem can be formally defined as follows.

Problem Definition (${\sf RP}$)

*The input consists of a graph $G=({\cal V},E)$, a set of clients ${\cal A}$ and a capacity $W$. Each client $a$ is attached to a node $u\in{\cal V}$, denoted ${\tt att}(a)$. For each client $a\in{\cal A}$, the input specifies a request $r(a)$ and a distance $d_{\max}(a)$. For a client $a\in{\cal A}$ and a node $u\in{\cal V}$, let $d(a,u)$ denote the length of the shortest path between $u$ and ${\tt att}(a)$, the node to which $a$ is attached - the length is measured by the number of edges and we take $d(a,u)=0$, if $u={\tt att}(a)$. We say that a client $a\in{\cal A}$ can access a node $u\in{\cal V}$, if $d(a,u)$ is at most $d_{\max}(a)$. A feasible solution consists of two parts: (i) it identifies a subset of nodes $S\subseteq{\cal V}$ where a replica is placed at each node in $S$; (ii) for each client $a\in{\cal A}$, it either opens a dedicated replica at $a$ itself for serving the client’s request or assigns the request to the replica at some node $u\in S$ accessible to $a$. The solution must satisfy the constraint that for each node $u\in S$, the sum of requests assigned to the replica at $u$ does not exceed $W$. The cost of the solution is the number of replicas opened, i.e., cardinality of $S$ plus the number of dedicated replicas opened at the clients. The goal is to compute a solution of minimum cost. In order to ensure feasibility, without loss of generality, we assume $r(a)\leq W$, $\forall\ a\in{\cal A}$. *$\Box$

The ${\sf RP}$ problem falls under the framework of the capacitated set cover problem, the generalization of the classical set cover problem wherein each set is associated with a capacity specifying the number of elements it can cover. The latter problem is known to have an $O(\log n)$-approximation algorithm **[5]**. Using the above result, we can derive an $O(\log n)$-approximation algorithm for the ${\sf RP}$ problem as well. On the other hand, we can easily reduce the classical dominating set problem to ${\sf RP}$: given a graph representing an instance of the dominating set problem, we create a new client for each vertex and attach it to the vertex; then, we set $d_{\max}(\cdot)=1$ for all the clients and $W=\infty$. Since it is NP-hard to approximate the dominating set problem within a factor of $o(\log n)$ **[7]**, by the above reduction, we get the same hardness result for the ${\sf RP}$ problem as well.

The ${\sf RP}$ problem is NP-hard even on the highly restricted special case where the graph is simply a path, as can be seen via the following reduction from the bin packing problem. Given $K$ bins of capacity $W$ and a set of items of sizes $s_{1},s_{2},\ldots,s_{n}$, for each item $i$, we create a client $a$ with demand $r(a)=s_{i}$. We then construct a path of nodes of length $K$ and attach all the clients to one end of the path and take $W$ to be the capacity of the nodes.

Prior Results

Prior work has studied a variant of the ${\sf RP}$ problem where the network is a directed acyclic graph (DAG), and a client $a$ can access a node $u$ only if there is a directed path from $a$ to $u$ of the length at most $d_{\max}(a)$. Under this setting, Benoit et al. **[3]** considered the special case of rooted trees and presented a greedy algorithm with an approximation ratio of $O(\Delta)$, where $\Delta$ is the maximum degree of the tree. For the same problem, Arora et al. **[2]** (overlapping set of authors) devised a constant factor approximation algorithm via LP rounding.

Progress has been made on generalizing the above result to the case of bounded treewidth DAGs. Recall that treewidth **[4]** is a classical parameter used for measuring how close a given graph is to being a tree (a formal definition is included in Section 2). For a DAG, the treewidth refers to the treewidth $t$ of the underlying undirected graph. Notice that the reduction from the bin-packing problem shows that the problem is NP-hard even for trees (i.e., $t=1$) and rules out the possibility of designing an exact algorithm running in time $n^{O(t)}$ (say via dynamic programming) or FPT algorithms with parameter $t$.

Arora et al. **[1]** made progress towards handling DAGs of bounded treewidth and designed an algorithm for the case of bounded-degree, bounded-treewidth graphs. Their algorithm achieves an approximation ratio of $O(\Delta+t)$, where $\Delta$ is the maximum degree and $t$ is the treewidth of the DAG. Their result also extends for networks comprising of bounded-degree bounded-treewidth subgraphs connected in a tree like fashion.

Our Result and Discussion

We study the ${\sf RP}$ problem on undirected graphs of bounded treewidth. Our main result is an $O(t)$-approximation algorithm running in time $O(n^{c})$, where the exponent $c$ is a constant independent of the treewidth $t$. In contrast to prior work, the approximation ratio depends only on the treewidth and is independent of other parameters such as the maximum degree.

Our algorithm is based on rounding solutions to a natural LP formulation, as in the case of prior work **[2, 1]**. However, the prior algorithms exploit the acyclic nature of the graphs and the bounded degree assumption to transform a given LP solution to a solution wherein each client is assigned to at most two replicas. In other words, they reduce the problem to a capacitated vertex cover setting, for which constant factor rounding algorithms are known **[11]**.

The above reduction does not extend to the case of general bounded treewidth graphs. Our algorithm is based on an entirely different approach. We introduce the notion of “clustered solutions”, wherein the partially open nodes are grouped into clusters and each client gets served only within a cluster. We show how to transform a given LP solution to a new solution in which a partially-open node participates in at most $(t+1)$ clusters. This allows us to derive an overall approximation ratio $O(t)$. The notion of clustered solutions may be applicable in other capacitated set cover settings as well.

Other Related Work

As mentioned earlier, the ${\sf RP}$ problem falls under the framework of the capacitated set cover problem $({\sf CSC})$, which admits an $O(\log n)$-approximation algorithm **[5]**. Two versions of the ${\sf CSC}$ problem and its special cases have been considered: soft capacity and hard capacity settings. Our work falls under the more challenging hard capacity setting, wherein a set can be picked at most once. The capacitated versions of the vertex cover problem (e.g., **[11]**) and dominating set problem (e.g., **[9]**) have also been studied. Our result applies to the capacitated dominating problem with uniform capacities and yields an $O(t)$-approximation algorithm. The ${\sf RP}$ problem is also related to the capacitated facility location framework (e.g., **[10]**) However, a crucial difference is that ${\sf RP}$ is concerned only with whether or not a client can access a facility, and its cost model does not include the distance between clients and facilities.

2 Preliminaries

Here we define the notion of tree decomposition. A tree decomposition of a graph $G=(V,E)$ is a pair $(X=\{X_{j}:j\in J\},T=(J,K))$, where $T$ is a tree over the nodes $J$ and each node $j\in J$ is associated with a subset of vertices $X_{j}\subseteq V$ such that the following three conditions are satisfied: (i) each vertex belongs to at least one bag, i.e., $\bigcup_{j\in J}X_{j}=V$; (ii) for every edge $(u,v)\in E$, there is a bag containing both $u$ and $v$; and (iii) for all vertices $v\in V$, the set of nodes $\{j\in J:v\in X_{j}\}$ induces a subtree of $T$. The subsets $X_{j}$ are called bags. The width of the tree decomposition is defined to be $\max_{j\in J}\left(|X_{j}|-1\right)$. The treewidth $t$ of a graph $G$ is the minimum width over all tree decompositions of $G$. It is NP-hard to find the tree decomposition of minimum width, but fixed parameter tractable algorithms are known.

3 Overview of the Algorithm

Our $O(t)$-approximation algorithm is based on rounding solution to a natural LP formulation. In this section, we present an outline of the algorithm highlighting its main features, deferring a detailed description to subsequent sections. We assume that the input includes a decomposition ${\cal T}$ of treewidth $t$ of the input network $G=({\cal V},E)$.

LP Formulation

For each node $u\in{\cal V}$, we introduce a variable $y(u)$ to represent the extent to which a replica is opened at $u$ and similarly, for each client $a\in{\cal A}$, we add a variable $y(a)$ to represent the extent to which a dedicated replica is opened at $a$ itself. For each client $a\in{\cal A}$ and each node $u\in{\cal V}$ accessible to $a$, we use a variable $x(a,u)$ to represent the extent to which $a$ is assigned to $u$. For a client $a\in{\cal A}$ and a node $u\in{\cal V}$, we use the shorthand “$a\sim u$” to mean that $a$ can access $u$.

[TABLE]

Constraint (3) stipulates that a client $a$ cannot be serviced at a node $u$ for an amount exceeding the extent to which $u$ is open. For an LP solution $\sigma=\langle x,y\rangle$, let ${\rm cost}(\sigma)$ denote the objective value of $\sigma$.

The following simple notations will be useful in our discussion. With respect to an LP solution $\sigma$, we classify the nodes into three categories based on the extent to which they are open. A node $u$ is said to be fully-open, if $y(u)=1$; partially-open, if $0<y(u)<1$; and fully-closed, if $y(u)=0$. A client $a$ is said to be assigned to a node $u$, if $x(a,u)>0$. For a set of nodes $U$, let $y(U)$ denote the extent to which the vertices in $U$ are open, i.e., $y(U)=\sum_{u\in U}y(u)$.

Outline

The major part of the rounding procedure involves transforming a given LP solution $\sigma_{{\rm in}}=\langle x_{{\rm in}},y_{{\rm in}}\rangle$ into an integrally open solution: wherein which each node $u\in{\cal V}$ is either fully open or closed. Such a solution differs from an integral solution as a client may be assigned to multiple nodes (possibly to its own dedicated replica as well). We address the issue easily via a cycle cancellation procedure to get an integral solution.

The procedure for obtaining an integrally open solution works in two stages. First it transforms the input solution into a “clustered” solution, which is then transformed into an integrally open solution. The notion of clustered solution lies at the heart of the rounding algorithm. Intuitively, in a clustered solution, the set of partially open (and closed) nodes are partitioned into a collection of clusters ${\cal C}$ and the clients can be partitioned into a set of corresponding groups satisfying three useful properties, as discussed below.

Let $\sigma=\langle x,y\rangle$ be an LP solution. It will be convenient to express the three properties using the notion of linkage: we say that a node $u$ is linked to a node $v$, if there exists a client $a$ assigned to both $u$ and $v$. For constants $\alpha$ and $\ell$, the solution $\sigma$ is said to be $(\alpha,\ell)$-clustered, if the set of partially-open nodes can be partitioned into a collection of clusters, ${\cal C}=\{C_{1},C_{2},\ldots,C_{k}\}$ (for some $k$), such that the the following properties are true:

• •

Localization: assignments from clients to the partially-open nodes is localized, i.e., two partially-open nodes are linked only if they belong to the same cluster.

• •

Distributivity: assignments from the clients to fully-open nodes are restricted, i.e., for any $C_{j}$, there are at most $\ell$ fully-open nodes that are linked to the nodes in $C_{j}$.

• •

Bounded opening: clusters are tiny, i.e., the total extent to which any cluster is open is at most $\alpha$, i.e., $y(C_{j})<\alpha$.

Figure 1 provides an illustration. In the first stage of the rounding algorithm, we transform the input solution $\sigma_{{\rm in}}$ into an $(\alpha,t+1)$-clustered solution with the additional guarantee that the number of clusters is at most a constant factor of ${\rm cost}(\sigma_{{\rm in}})$, where $\alpha\in[0,1/2]$ is a tunable parameter. The lemma below specifies the transformation performed by the first stage.

Lemma 3.1

Fix any constant $\alpha\leq 1/2$. Any LP solution $\sigma$ can be transformed into a $(\alpha,t+1)$-clustered solution $\sigma^{\prime}$ such that ${\rm cost}(\sigma^{\prime})$ is at most $2+6(t+1){\rm cost}(\sigma)/\alpha$. Furthermore, the number of clusters is at most $3+8\cdot{\rm cost}(\sigma)/\alpha$.

At a high level, the lemma is proved by considering the tree decomposition ${\cal T}$ of the input graph $G=({\cal V},E)$ and performing a bottom-up traversal that identifies a suitable set of boundary bags. We use these boundary bags to split the tree into a set of disjoint regions and create one cluster per region. We then fully open the nodes in the boundary bags and transfer assignments from the nodes that stay partially-open to these fully-open nodes. The transfer of assignments is performed in such a manner that clusters get localized and have distributivity of $(t+1)$. By carefully selecting the boundary bags, we shall enforce that each cluster is open to an extent of only $\alpha$ and that the number of clusters is also bounded. The proof is discussed in Section 4.

The goal of the second stage is to transform a $(1/4,t+1)$-clustered solution (obtained from Lemma 3.1) into an integrally open solution. At a high level, the localization property allows us to independently process each cluster $C\in{\cal C}$ and its corresponding group of clients $A$. The clients in $A$ are assigned to a set of fully-open nodes, say $F$. For each node $u\in F$, we identify a suitable node $v\in C$ called the “consort” of $u\in C$ and fully open $v$. Then the idea is to transfer assignments from the non-consort nodes to the nodes in $F$ and their consorts in such a manner that at the end, no client is assigned to the non-consort nodes. This allows us to fully close the non-consort nodes. The localization and bounded opening properties facilitate the above maneuver. On the other hand, the distributivity property ensures that $F$ is at most $(t+1)$. This means that we fully open at most $(t+1)$ consorts per cluster. Thus, overall increase in cost is at most $(t+1)|{\cal C}|$. Since $|{\cal C}|$ is guaranteed to be linear in ${\rm cost}(\sigma_{{\rm in}})$, we get an $O(t)$ approximation factor.

Lemma 3.2

Let $\sigma=\langle x,y\rangle$ be a $(1/4,t+1)$-clustered solution via a collection of clusters ${\cal C}$. The solution can be transformed into an integrally open solution $\sigma^{\prime}=\langle x^{\prime},y^{\prime}\rangle$ such that ${\rm cost}(\sigma^{\prime})\leq 2\cdot{\rm cost}(\sigma)+2(t+1)|{\cal C}|$.

Once we obtain an integrally open solution, it can easily be transformed to an integral solution by applying a cycle cancellation strategy, as given by the following lemma.

Lemma 3.3

Any integrally open solution $\sigma=\langle x,y\rangle$ can be transformed to an integral solution $\sigma^{\prime}=\langle x^{\prime},y^{\prime}\rangle$ such that ${\rm cost}(\sigma^{\prime})\leq 4\cdot{\rm cost}(\sigma)$.

We can transform any input LP solution $\sigma_{{\rm in}}$ into an integral solution $\sigma_{{\rm out}}$ by applying the above three transformations leading to the following main result of the paper.

Theorem 3.4

The ${\sf RP}$ problem admits an $O(t)$-approximation poly-time algorithm.

Proof:*   We fix $\alpha=1/4$ and apply Lemma 3.1 to obtain a solution $\sigma_{1}$, which is $(1/4,t+1)$-clustered via a collection of clusters ${\cal C}$. It is guaranteed that ${\rm cost}(\sigma_{1})\leq 2+24(t+1){\rm cost}(\sigma_{{\rm in}})$ and $|{\cal C}|\leq 3+32\cdot{\rm cost}(\sigma_{{\rm in}})$. We next apply Lemma 3.2 on the solution $\sigma_{1}$ and obtain an integrally open solution $\sigma_{2}$ such that ${\rm cost}(\sigma_{2})\leq 2\cdot{\rm cost}(\sigma_{1})+2(t+1)|{\cal C}|$. Finally, we transform $\sigma_{2}$ into integral solution $\sigma_{{\rm out}}$ using Lemma 3.3 such that ${\rm cost}(\sigma_{{\rm out}})\leq 4\cdot{\rm cost}(\sigma_{2})$. It follows that ${\rm cost}(\sigma_{{\rm out}})$ is at most $16+24(t+1)+448(t+1){\rm cost}(\sigma_{{\rm in}})$. Thus, the overall approximation ratio is $O(t)$. *$\Box$

The constant factor involved in the approximation ratio can be improved by more careful book keeping - however, we refrain from doing so, for the ease of exposition. The rest of the paper is devoted to proving Lemma 3.1, 3.2 and 3.3.

4 Clustered Solution: Proof of Lemma 3.1

The goal is to transform a given solution into an $(\alpha,t+1)$-clustered solution with the properties claimed in the lemma. The idea is to select a set of partially-open or closed nodes and open them fully, and then transfer assignments from the other partially-open nodes to them in such a manner that the partially-open nodes get partitioned into clusters satisfying the three properties of clustered solutions. An issue in executing the above plan is that the capacity at a newly opened node may be exceeded during the transfer. We circumvent the issue by first performing a pre-processing step called de-capacitation.

4.1 De-capacitation

Consider an LP solution $\sigma=\langle x,y\rangle$ and let $u$ be a partially-open or closed node. The clients that can access $u$ might have been assigned to other partially-open nodes under $\sigma$. We call the node $u$ de-capacitated, if even when all the above assignments are transferred to $u$, the capacity at $u$ is not exceeded; meaning,

[TABLE]

where ${\sf PO}$ is the set of partially-open nodes under $\sigma$ (including $u$). The solution $\sigma$ is said to be de-capacitated, if all the partially-open and the closed nodes are de-capacitated.

The preprocessing step transforms the input solution into a de-capacitated solution by performing a pulling procedure on the partially-open and closed nodes. Given a partially-open or closed node $u$, the procedure transfers assignments from other partially-open nodes to $u$, as long as the capacity at $u$ is not violated. The procedure is shown in Figure 2, which we make use of in other components of the algorithm as well.

Lemma 4.1

Any LP solution $\sigma=\langle x,y\rangle$ can be transformed into a de-capacitated solution $\sigma^{\prime}=\langle x^{\prime},y^{\prime}\rangle$ such that ${\rm cost}(\sigma^{\prime})\leq 2\cdot{\rm cost}(\sigma)$.

Proof:*   We consider the partially-open and closed nodes, and process them in an arbitrary order, as follows. Let $u$ be a partially-open or closed node. Hypothetically, consider applying the pulling procedure on $u$. The procedure may terminate in one of two ways: (i) it exits mid-way because of reaching the capacity limit; (ii) the process executes in its entirety. In the former case, we fully open $u$ and perform the pulling procedure on $u$. In the latter case, the node $u$ is de-capacitated and so, we leave it as partially-open or closed, without performing the pulling procedure. It is clear that the above method produces a de-capacitated solution $\sigma^{\prime}$. We next analyze the cost of $\sigma^{\prime}$. Let $s$ be the number of partially-open or closed nodes converted to be fully-open. Apart from these conversions, the method does not alter the cost and so, ${\rm cost}(\sigma^{\prime})$ is at most $s+{\rm cost}(\sigma)$. Let the total amount of requests be $r_{\rm tot}=\sum_{a\in{\cal A}}r(a)$. The extra cost $s$ is at most $\lfloor r_{\rm tot}/W\rfloor$, since any newly opened node is filled to its capacity. Due to the capacity constraints, the input solution $\sigma$ must also incur a cost of at least $\lfloor r_{\rm tot}/W\rfloor$. It follows that ${\rm cost}(\sigma^{\prime})$ is at most $2\cdot{\rm cost}(\sigma)$. *$\Box$

4.2 Clustering

Given Lemma 4.1, assume that we have a de-capacitated solution $\sigma=\langle x,y\rangle$. We next discuss how to transform $\sigma$ into an $(\alpha,t+1)$-clustered solution. The transformation would perform a bottom-up traversal of the tree decomposition and identify a set of partially-open or closed nodes. It would then fully open them and perform the pulling procedure on these nodes. The advantage is that the above nodes are de-capacitated and so, the pulling procedure would run to its entirety (without having to exit mid-way because of reaching capacity limits). As a consequence, the linkage between the nodes gets restricted, leading to an clustered solution. Below we first describe the transformation and then present an analysis.

Transformation

Consider the given tree decomposition ${\cal T}$. We select an arbitrary bag of ${\cal T}$ and make it the root. A bag $P$ is said to be an ancestor of a bag $Q$, if $P$ lies on the path connecting $Q$ and the root; in this case, $Q$ is called a descendant of $P$. We consider $P$ to be both an ancestor and descendant of itself. A node $u$ may occur in multiple bags; among these bags the one closest to the root is called the anchor of $u$ and it is denoted ${\tt anchor}(u)$. A region in ${\cal T}$ refers to any set of contiguous bags (i.e., the set of bags induce a connected sub-tree).

In transforming $\sigma$ into a clustered solution, we shall encounter three types of nodes and it will be convenient to color them as red, blue and brown. To start with, all the fully-open nodes are colored red and the remaining nodes (partially-open nodes and closed nodes) are colored blue. The idea is to carefully select a set of blue nodes, fully-open them and perform the pulling procedure on these nodes; these nodes are then colored brown. Thus, while the blue nodes are partially-open or closed, the red and the brown nodes are fully-open, with the brown and blue nodes being de-capacitated.

The transformation identifies two kinds of nodes to be colored brown, helpers and boundary nodes. We say that a red node $u\in{\cal V}$ is proper, if it has at least one neighbor $v\in{\cal V}$ which is a blue node. For each such proper red node $u$, we arbitrarily select one such blue neighbor $v\in{\cal V}$ and declare it to be the helper of $u$. Multiple red nodes are allowed to share the same helper. Once the helpers have been identified, we color them all brown. The boundary brown nodes are selected via a more involved bottom-up traversal of ${\cal T}$ that works by identifying a set ${\cal B}$ of bags, called the boundary bags. To start with, ${\cal B}$ is initialized to be the empty set. We arrange the bags in ${\cal T}$ in any bottom-up order (i.e., a bag gets listed only after all its children are listed) and then iteratively process each bag $P$ as per the above order. Consider a bag $P$. We define the region headed by $P$, denoted ${\tt Region}(P)$, to be the set of bags $Q$ such that $Q$ is a descendant of $P$, but not the descendant of any bag already in ${\cal B}$. See Figure 3 for an illustration. A blue node $u$ is said to be active at $P$, if it occurs in some bag included in ${\tt Region}(P)$. Let ${\tt active}(P)$ denote the set of blue nodes active at $P$. We declare $P$ to be a boundary bag and add it to ${\cal B}$ under three scenarios: (i) $P$ is the root bag. (ii) $P$ is the anchor of some red node. (iii) the extent to which the nodes in ${\tt active}(P)$ are open is at least $\alpha$, i.e., $\sum_{u\in{\tt active}(P)}y(u)\geq\alpha$. If $P$ is identified as a boundary bag, then we select all the blue nodes appearing in the bag and change their color to be brown. Once the bottom-up traversal is completed, we have a set of brown nodes (helpers and boundary nodes). We consider these nodes in any arbitrary order, open them fully, and perform the pulling procedure on them. We take $\sigma^{\prime}$ to be the solution obtained by the above process. This completes the construction of $\sigma^{\prime}$. We note that a node may change its color from blue to brown in the above process, and the new color is to be considered while determining the active sets thereafter. Notice that during the whole process of the above transformation, the solution continues to remain de-capacitated. A pseudocode is presented in Figure 4.

Analysis

We now show that $\sigma^{\prime}$ is an $(\alpha,t+1)$-clustered solution. To start with, we have a set of red nodes that are fully-open and a set of blue nodes that are either partially-open or closed under $\sigma$. The red nodes do not change color during the transformation. On the other hand, each blue node $u$ becomes active at some boundary bag $P$. If $u$ occurs in the bag $P$, it changes its color to brown, otherwise it stays blue. Thus, the transformation partitions the set of originally blue nodes into a set of brown nodes and a set of nodes that stay blue. In the following discussion, we shall use the term ‘blue’ to refer to the nodes that stay blue. With respect to the solution $\sigma^{\prime}$, the red and brown nodes are fully-open, whereas the blue nodes are partially-open or closed.

Recall that with respect to $\sigma^{\prime}$, two nodes $u$ and $v$ are linked, if there is a client $a$ assigned to both $u$ and $v$. In order to prove the properties of $(\alpha,t+1)$-clustering, we need to analyze the linkage information for the blue nodes. We first show that the blue nodes cannot be linked to brown nodes, by proving the following stronger observation.

Proposition 4.1

If a client $a\in{\cal A}$ is assigned to a blue node $u$ under $\sigma^{\prime}$, then $a$ cannot access any brown node $v$.

Proof:*   As part of the transformation, we perform the pulling procedure on the brown node $v$. Since $\sigma$ is de-capacitated, the node $v$ is de-capacitated under $\sigma$. As a result, the pulling procedure on $v$ would run to its entirety (without having to exit mid-way because of reaching the capacity limit). This means that the assignment $x(a,u)$ would get transferred to $v$. Thus, under $\sigma^{\prime}$, the client $a$ cannot remain assigned to $u$, contradicting the assumption in the lemma statement. *$\Box$

Proposition 4.1 rules out the possibility of a blue node $u$ being linked to any brown node. Thus, $u$ may be linked to a red node or another blue node. The following lemmas establish a crucial property on the connectivity in these two settings.

Lemma 4.2

If two blue nodes $u$ and $v$ are linked under $\sigma^{\prime}$, then there must exist a path connecting $u$ and $v$ consisting of only blue nodes.

Proof:*   Let $a$ be any client that is assigned to both $u$ and $v$. Consider any shortest path $p_{1}$ between $u$ and ${\tt att}(a)$ (the node to which the client $a$ is attached in the network). The path cannot contain any brown node $w$, because in this case, $d(a,w)$ would be smaller than $d(a,u)$, making $w$ accessible to $a$. This would contradict Proposition 4.1. In a similar vein, we claim that the path cannot contain any red node. For otherwise, traverse the path from ${\tt att}(a)$ to $u$, and let $w$ be the last red node encountered on the path. Let $z$ be the node succeeding $w$ (it may be the case that $z=u$). The node $z$ is blue and is a neighbor of $w$ in the graph. This means that $w$ is a proper red node and must have a brown helper $h$. We have that $d(a,w)\leq d(a,u)-1$ and $d(a,h)\leq d(a,w)+1$, and hence $d(a,h)\leq d_{\max}(a)$. This means that $a$ can access $h$, contradicting Proposition 4.1. We have shown that the path $p_{1}$ consists of only blue nodes.*

*The same argument also shows that any shortest path $p_{2}$ connecting ${\tt att}(a)$ and $v$ must also consists of only blue nodes. The path $p_{1}$ connects $u$ and ${\tt att}(a)$, and the path $p_{2}$ connects ${\tt att}(a)$ and $v$. By combining the two, we can construct a path $p^{\prime}$ connecting $u$ and $v$. The path $p^{\prime}$ may not be simple, but we can trim it to obtain a simple path $p$ connecting $u$ and $v$. The path $p$ contains only blue nodes. *$\Box$

Lemma 4.3

If a blue node $u$ is linked to a red node $v$ under $\sigma^{\prime}$, then there must exist a path $p$ connecting $u$ and $v$ such that barring $v$, the path consists of only blue nodes.

Proof:*   Let $a$ be a client assigned to both $u$ and $v$ under $\sigma^{\prime}$. Let $p_{1}$ and $p_{2}$ be any shortest paths connecting ${\tt att}(a)$ with $u$ and $v$, respectively. As argued in Lemma 4.2, the two paths cannot contain any brown nodes and furthermore, $p_{1}$ must contain only blue nodes. This implies that the node to which $a$ is attached, ${\tt att}(a)$, must also be a blue node.*

We claim that the path $p_{2}$ cannot contain any red nodes, barring $v$. By contradiction, suppose such a red node exists. Traverse the path from ${\tt att}(a)$ to $v$. The first node on the path is ${\tt att}(a)$, a blue node, and continuing further, let $w$ be the first red node encountered. The node preceding $w$ is a blue node. It follows that $w$ is a proper red node and so, it must have a brown helper $h$. Furthermore, $d(a,w)\leq d(a,v)-1$ and $d(a,h)\leq d(a,w)+1$. Thus, $d(a,h)\leq d_{\max}(a)$, which implies that $a$ can access the brown node $h$, contradicting Proposition 4.1.

*We have shown that barring $v$, the paths $p_{1}$ and $p_{2}$ consist of only blue nodes. By combining the two paths, we can obtain the path $p$ claimed in the lemma. *$\Box$

The transformation outputs a set of boundary bags ${\cal B}$; let $\overline{\cal B}$ denote the set of non-boundary bags. If we treat the bags in ${\cal B}$ as cut-vertices and delete them from ${\cal T}$, the tree splits into a collection ${\cal R}$ of disjoint regions. Alternatively, these regions can be identified in the following manner. For each bag $P\in{\cal B}$ and each of its non-boundary child $Q\in\overline{\cal B}$, add the region headed by $Q$ (${\tt Region}(Q)$) to the collection ${\cal R}$. Let the collection derived be ${\cal R}=\{R_{1},R_{2},\ldots,R_{k}\}$. It is easy to see that ${\cal R}$ partitions $\overline{\cal B}$ and that the regions in ${\cal R}$ are pairwise disconnected (not connected by edges of the tree decomposition). We next make two observations regarding connectivity among the regions, with the second one being a generalization of the first.

Proposition 4.2

Consider any region $R_{j}\in{\cal R}$. Let $u$ and $v$ be two nodes such that $u$ occurs only in the bags of $R_{j}$, whereas $v$ does not occur in any bag of $R_{j}$. Then, any path $p$ in $G$ connecting $u$ and $v$ must pass through some boundary bag $X$, i.e., one of the nodes of $p$ must occur in $X$.

Proposition 4.3

Consider any region $R_{j}\in{\cal R}$. Let $Q$ be the bag heading $R_{j}$ and let $P\in{\cal B}$ be its parent bag. Let $u$ and $v$ be two nodes such that $u$ occurs only in the bags of $R_{j}$, $v$ does not occur in $P$ and ${\tt anchor}(v)$ does not belong to $R_{j}$. Then, any path $p$ connecting $u$ and $v$ must include a node $w\neq v$ such that $w$ occurs in $P$ or ${\tt anchor}(v)$.

The two propositions can be proved by appealing to the properties of tree decompositions. The first follows as a direct consequence of these properties. We can prove the second by arguing two cases: (i) if ${\tt anchor}(v)$ is a descendant of $P$, then the path $p$ must include a node $w\neq v$ occurring in ${\tt anchor}(v)$; (ii) if ${\tt anchor}(v)$ is not a descendant of $P$, the path must include a node $w\neq v$ occurring in $P$.

We are now ready to show that $\sigma^{\prime}$ is an $(\alpha,t+1)$-clustered solution. Towards that goal, let us suitably partition the set of partially open nodes into a collection of clusters ${\cal C}$. For each region $R_{j}$, let $C_{j}$ be the set of partially open nodes that occur in some bag of $R_{j}$. We take ${\cal C}$ to be the collection $\{C_{1},C_{2},\ldots,C_{k}\}$.

Let us verify that the collection ${\cal C}$ constructed above is indeed a partitioning of the set of partially open nodes. Firstly, we can see that any partially open node $u$ must belong to some cluster $C_{j}$: the node $u$ cannot occur in any boundary bag (for otherwise, $u$ would have turned brown) and so, it must occur in a non-boundary bag found in some region $R_{j}$ and would get included in $C_{j}$. Secondly, any partially open node $u$ cannot belong to two clusters $C_{i}$ and $C_{j}$. For otherwise, $u$ must occur in some bags $Q_{1}\in R_{i}$ and $Q_{2}\in R_{j}$. Since $R_{i}$ and $R_{j}$ are disconnected, the (unique) path connecting $Q_{1}$ and $Q_{2}$ in ${\cal T}$ must pass through some boundary bag $P$. By the properties of tree decomposition, the node $u$ must also occur in $P$. In this case, $u$ would have turned brown, contradicting the assumption that $u$ is partially open, and hence blue.

We next argue that ${\cal C}$ satisfies the three properties of localization, distributivity and bounded opening. However, the number of clusters in the collection may exceed the bound claimed in Lemma 3.1. Later, we show that the issue can be easily rectified by suitably merging the clusters.

Lemma 4.4

The solution $\sigma^{\prime}$ is $(\alpha,t+1)$-clustered.

Proof:*   We prove the collection ${\cal C}$ satisfies the three properties.*

Localization: We need to show that any two linked blue nodes $u$ and $v$ belong to the same cluster. By contradiction, suppose that there exist two blue nodes $u$ and $v$ belonging to two different clusters $C_{i}$ and $C_{j}$ such that a common client $a$ is assigned to both of them under $\sigma^{\prime}$. Lemma 4.2 shows that $u$ and $v$ are connected by a path $p$ consisting only of blue nodes. By the construction of the clusters, $u$ and $v$ occur only in the bags of the regions $R_{i}$ and $R_{j}$, respectively. Thus, by Proposition 4.2, some node $w$ found in $p$ must occur in some boundary bag $P$. However, in this case, the transformation would have turned the blue node $w$ to a brown node, contradicting the fact that $w$ stayed blue.

Distributivity: Consider any cluster $C_{j}$ and any node $u\in C_{j}$. Let $Q$ be the bag heading the corresponding region $R_{j}$ and let $P$ be the parent bag of $Q$. We claim that any red node $v$ linked to $u$ must occur in $P$. By contradiction suppose $v$ does not occur in $P$. By Lemma 4.3, there must exist a path $p$ connecting $u$ and $v$, which is made of all blue nodes, barring $v$. The bag $\widehat{P}={\tt anchor}(v)$ cannot belong to the region $R_{j}$; for otherwise, the transformation would have made $\widehat{P}$ into a boundary bag, but the region $R_{j}$ consists of only non-boundary bags. Thus, Proposition 4.3 implies that the path $p$ must include a node $w\neq v$ such that $w$ occurs in $P$ or ${\tt anchor}(v)$. Both $P$ and ${\tt anchor}(v)$ are boundary bags and $w$ is a blue node. In this case, the transformation would have turned $w$ to a brown node, contradicting the fact that $w$ stayed blue. The claim implies that all the red nodes that are linked to the blue nodes in $C_{j}$ occur in the bag $P$. Since ${\cal T}$ is a decomposition of width $t$, $P$ can contain at most $t+1$ elements. Thus, the blue nodes in $C_{j}$ can be linked to at most $t+1$ red nodes. In the solution $\sigma^{\prime}$, the red and brown nodes are fully-open. By Proposition 4.1, the brown nodes cannot be linked to blue nodes. We have thus proved that the clustering has distributivity parameter $t+1$.

*Bounded opening: We claim that each cluster $C_{j}$ is open to an extent of less than $\alpha$, i.e., $y(C_{j})<\alpha$. For otherwise, consider the corresponding region $R_{j}$ and the bag $Q$ heading $R_{j}$. Notice that if $y(C_{j})\geq\alpha$, the transformation would have made $Q$ itself to a boundary bag, but any region in the collection ${\cal R}$ contains only non-boundary nodes. *$\Box$

Cost Analysis:

Here we analyze the solution $\sigma^{\prime}=\langle x^{\prime},y^{\prime}\rangle$ and prove the bound claimed in Lemma 3.1. Let ${\tt Red}$, ${\tt Blue}$ and ${\tt Brown}$ denote the set of red, blue and brown nodes. Then, ${\rm cost}(\sigma^{\prime})$ is given by $|{\tt Red}|+|{\tt Brown}|+y^{\prime}({\tt Blue})+y({\cal A})$, where $y({\cal A})$ represents the extent to which dedicated replicas are opened, i.e., $y({\cal A})=\sum_{a\in{\cal A}}y(a)$. The red nodes do not change their color, for any blue node $u$, the extent to which it is open does not change and similarly, for any client $a$, $y(a)$ does not change. Thus, $|{\tt Red}|+y^{\prime}({\tt Blue})+y^{\prime}({\cal A})\leq{\rm cost}(\sigma)$ and hence, ${\rm cost}(\sigma^{\prime})\leq{\rm cost}(\sigma)+|{\tt Brown}|$. We create a brown helper node for each red node. Furthermore, for each boundary bag $P\in{\cal B}$, we convert all the blue nodes in $P$ to be brown, and the number of such blue nodes is at most $(t+1)$. Thus, $|{\tt Brown}|\leq|{\tt Red}|+(t+1)|{\cal B}|$. A bag $P$ is made a boundary bag under one of the three scenarios. (i) $P$ is the root bag; (ii) $P$ is the anchor of some red node; (iii) the total extent to which the nodes in ${\tt active}(P)$ are open is at least $\alpha$. The number of boundary bags of the first two types are $1+|{\tt Red}|$. Regarding the third scenario, notice that each originally blue node becomes active at a unique boundary bag. This is because, each originally blue node becomes active at some boundary piece $P$. If it occurs in $P$, then it turns brown and otherwise, by the properties of tree decomposition it cannot occur in the region of any other boundary bag. The total extent to which these originally blue nodes are open is at most ${\rm cost}(\sigma)$. Thus, the number boundary bags of the third type is at most $\lceil{\rm cost}(\sigma)/\alpha\rceil$. Therefore,

[TABLE]

It follows that ${\rm cost}(\sigma^{\prime})$ is at most ${\rm cost}(\sigma)+|{\tt Red}|+(t+1)(2+|{\tt Red}|+{\rm cost}(\sigma)/\alpha)$. A simple arithmetic shows that ${\rm cost}(\sigma^{\prime})$ is at most $2+3(t+1){\rm cost}(\sigma)/\alpha$ (we use the fact that $|{\tt Red}|\leq{\rm cost}(\sigma)$ and our assumption that the parameter $\alpha$ is at most $1/2$). The preprocessing step of de-capacitation incurs a 2-factor increase in cost. Taking this into account, we get the cost bound claimed in the statement of Lemma 3.1.

Number of Clusters:

As mentioned earlier, an issue with the collection ${\cal C}$ is that it may have more clusters than the bound claimed in Lemma 3.1. We reduce the number of clusters by suitably merging the clusters. Consider each boundary bag $P$. All the non-boundary children of $P$ have a corresponding cluster in ${\cal C}$ and let ${\cal C}_{P}$ denote the collection of these clusters. We start with the collection ${\cal C}_{P}$ and repeatedly perform the following merging operation. Select any two clusters $C$ and $C^{\prime}$ from ${\cal C}_{P}$ such that $y(C)\leq\alpha/2$ and $y(C^{\prime})\leq\alpha/2$ and merge the two into a single cluster. The process is stopped when we cannot find two such clusters. This way we get a set of new clusters all of which are open to an extent of at most $\alpha$. Furthermore, except for perhaps a single cluster, all the others are open to an extent of at least $\alpha/2$; we refer to these as normal clusters and the exceptional one as abnormal. We perform this processing for all the boundary bags and obtain a new collection ${\cal C}^{\prime}$. The number of abnormal clusters is at most $|{\cal B}|$. The collection ${\cal C}^{\prime}$ is a partitioning of ${\tt Blue}$ and each normal cluster is open to an extent of at least $\alpha/2$. Thus, the number of normal clusters can be at most $\lceil y^{\prime}({\tt Blue})/(\alpha/2)\rceil$, which is at most $\lceil 2{\rm cost}(\sigma)/\alpha\rceil$. Hence, the total number of clusters in ${\cal C}^{\prime}$ is at most $3+4{\rm cost}(\sigma)/\alpha$. The process of merging does not affect distributivity: as shown in the proof Lemma 4.4, for any two merged clusters, the partially-open nodes in the clusters can only be linked to the fully-open nodes found in the parent boundary piece and the count of such fully-open nodes can be at most $(t+1)$. The preprocessing step of de-capacitation increases cost by $2$-factor. Taking this into account, we get the bound on number of clusters claimed in the statement of Lemma 3.1.

5 Integrally Open Solution: Proof of Lemma 3.2

Our goal is to transform a given $(1/4,t+1)$-clustered solution $\sigma=\langle x,y\rangle$ into an integrally open solution $\sigma^{\prime}$. We classify the clients into two groups, small and large, based on the extent to which they are served by dedicated replicas: a client $a\in{\cal A}$ said to be small, if $y(a)<1/2$, and it is said to be large otherwise. Let ${\cal A}_{s}$ and ${\cal A}_{l}$ denote the set of small and large clients, respectively.

We pre-process the solution $\sigma$ by opening a dedicated replica at each large client $a$ and removing its assignments to the nodes (set $y(a)=1$ and set $x(a,u)=0$ for all nodes $u$ accessible to $a$). We see that the transformation at most doubles the cost and the solution remains $(1/4,t+1)$-clustered.

Consider the pre-processed solution $\sigma$. Let ${\cal C}$ denote the set of clusters (of the partially-open nodes) under $\sigma$. For each cluster $C\in{\cal C}$, we shall fully open a selected set of at most $2(t+1)$ nodes and fully close rest of the nodes in it.

We now describe the processing for a cluster $C\in{\cal C}$. Let $A\subseteq{\cal A}_{s}$ denote the set of clients assigned to the nodes in $C$. By the distributivity property, these clients are assigned to at most $(t+1)$ fully-open nodes, denoted $F=\{u_{1},u_{2},\ldots,u_{t+1}\}$. A client $a\in A$ may be assigned to multiple nodes from $F$. In our procedure, it would be convenient if each client is assigned to at most one node from $F$ and we obtain such a structure using the following proposition.

The proposition is proved via a cycle cancellation procedure that transfers assignments amongst the nodes in $F$. The procedure can ensure that, except for at most $|F|$ clients, every other client $a\in{\cal A}$ is assigned to at most one node from $F$. We open dedicated replicas at the exceptional clients and this results in an cost increase of at most $|F|$.

Proposition 5.1

Given a solution $\sigma=\langle x,y\rangle$, a set of fully-open nodes $F$ and a set of clients $A$, we can obtain a solution $\sigma^{\prime}=\langle x^{\prime},y^{\prime}\rangle$ such that each client $a\in A$ is assigned to at most one node from $F$. Furthermore, the transformation does not alter the other assignments, i.e., for any node $u\in{\cal V}$ and any client $a\in{\cal A}$, if $u\not\in F$ or $a\not\in A$, then $x^{\prime}(a,u)=x(a,u)$. Moreover, ${\rm cost}(\sigma^{\prime})\leq{\rm cost}(\sigma)+|F|$.

Proof:*   Construct an edge-weighted bipartite graph with nodes in $F$ on one side and the clients in $A$ on the other side. For a pair of nodes $u\in F$ and $a\in A$, add an edge between the two, if $a$ is assigned to $u$ under $\sigma$. In this case, we imagine that $a$ imposes a load of $x(a,u)r(a)$ on the node $u$ and represent the above quantity as the weight on the edge. The plan is to employ a standard cycle-cancellation strategy and make the graph acyclic. Towards that goal, consider any cycle in the graph. Since the graph is bipartite, the cycle must be of even length. Partition the edges in the cycles into two groups, odd and even, by alternating on the cycle. Let $e=(a,u)$ be the edge having the least weight and let $w_{\min}=x(a,u)r(a)$. Assume without loss of generality that $e$ is an odd edge. The idea is to decrease the load on all the odd edges by an amount $w_{\min}$ and increase the load on all the even edges by the same amount. This can be accomplished by adjusting the assignments as follows. For each edge $e^{\prime}=(a^{\prime},u^{\prime})$, compute $\delta=w_{\min}/r(a^{\prime})$. If $e^{\prime}$ is an odd edge, increase $x(a^{\prime},u^{\prime})$ by an amount $\delta$, and otherwise, decrease $x(a^{\prime},u^{\prime})$ by an amount $\delta$. The edge weights are recomputed accordingly. The above process makes the assignment $x(a,u)$ to be zero and so, we can delete the edge, thereby breaking the cycle. We repeat the process until the bipartite graph becomes acyclic, i.e., a forest.*

Consider the resultant LP solution. The forest provides us information on the nodes that the clients are assigned to: a client $a\in A$ is assigned to a node $u\in F$, if $u$ is a neighbor of $a$ in the forest. Thus, any client $a\in A$ appearing as a leaf (vertex of degree one) is assigned to only a single node from $F$. These clients satisfy the property claimed in the proposition. This leaves us with having to deal with clients having multiple neighbors – let $A^{\prime}$ denote the set of such clients. We handle these clients simply by opening a dedicated replica at the client node itself. The process produces a solution $\sigma^{\prime}$ wherein each client $a\in A$ is assigned to at most one node $u\in F$.

*The above process incurs an extra cost of one unit per dedicated replica and so, the total increase in cost is $|A^{\prime}|$. It is not difficult to argue that $|A^{\prime}|\leq|F|$. To prove this, we shall produce a one-to-one mapping from $A^{\prime}$ to $F$. Consider each tree in the forest and root it at an arbitrary node from $F$. Since the graph is bipartite, the nodes from $F$ and the clients from $A$ appear in alternate levels of the tree. Thus, for any client $a\in A^{\prime}$, all its children are from $F$. For each client $a\in A^{\prime}$, pick one of its children $u\in F$ and map $a$ to $u$. This is a one-to-one mapping and so, $|A^{\prime}|\leq|F|$. We have shown that ${\rm cost}(\sigma^{\prime})\leq{\rm cost}(\sigma)+|F|$. *$\Box$

The proposition does not alter the other assignments and so, its output solution is also $(1/4,t+1)$-clustered. Given the proposition and the pre-processing, we can assume that $\sigma=\langle x,y\rangle$ is $(1/4,t+1)$-clustered wherein each client $a\in A$ is assigned to at most one node from $F$ and that $y(a)<1/2$. For each node $u_{i}\in F$, let $A_{i}\subseteq A$ denote the set of clients assigned to the node $u_{i}$. The proposition guarantees that these sets are disjoint.

For a node $v$ and a client $a$, let ${\tt load}(a,v)$ denote the amount of load imposed by $a$ on $v$ towards the capacity: ${\tt load}(a,v)=x(a,v)r(a)$. It will be convenient to define the notion over sets of clients and nodes. For a set of clients $B$ and a set of nodes $U$, let ${\tt load}(B,U)$ denote the load imposed by the clients in $B$ on the nodes $U$: ${\tt load}(B,U)=\sum_{a\in B,v\in U:a\sim v}x(a,v)r(a)$; when the sets are singletons, we shall omit the curly braces. Similarly, for a subset $C^{\prime}\subseteq C$, let ${\tt load}(C^{\prime})=\sum_{v\in C^{\prime}}{\tt load}(v)$.

The intuition behind the remaining transformation is as follows. We shall identify a suitable set of nodes $L=\{v_{1},v_{2},\ldots,v_{t+1}\}$ from $C$, with $v_{i}$ being called the consort of $u_{i}\in C$, and fully open all these nodes. Then, we consider the non-consort nodes $C^{\prime}=C-L$ and for each $i\leq t+1$, we transfer the load ${\tt load}(A_{i},C^{\prime})$ to the node $u_{i}$. As a result, no clients are assigned to the non-consort nodes any more and so, they can be fully closed. In order to execute the transfer, for each $i\leq t+1$, we create space in $u_{i}$ by pushing a load equivalent to ${\tt load}(A_{i},C^{\prime})$ from $u_{i}$ to its (fully-opened) consort $v_{i}$. The amount of load ${\tt load}(A_{i},C^{\prime})$ involved in the transfer is very small: the bounded opening property ensures that $y(C)<1/4$ and thus, ${\tt load}(A_{i},C^{\prime})<W/4$. The fully-opened consort $v_{i}$ has enough additional space to receive the load: $y(v_{i})\leq 1/4$ and so, ${\tt load}(A,v_{i})<W/4$, which means that if we fully open the consort, we get an additional space of $(3/4)W$. However, an important issue is that a consort $v_{i}$ may not be accessible to all the clients in $A_{i}$. Therefore, we need to carefully choose the consorts in such a manner that each fully open node $u_{i}$ has enough load accessible to the consort $v_{i}$ that can be pushed to $v_{i}$. Towards this purpose, we define the notion of pushable load. For a node $u_{i}\in F$ and a node $v\in C$, let ${\tt pushable}(u_{i},v)$ denote the amount of load on $u_{i}$ that is accessible to $v$: ${\tt pushable}(u_{i},v)=\sum_{a\in A_{i}:a\sim v}x(a,u_{i})r(a)$. We next show how to identify a suitable set of consorts such that the pushable load is more than the load that we wish to transfer.

Lemma 5.1

We can find a set of nodes $L=\{v_{1},v_{2},\ldots,v_{t+1}\}$ such that for all $i\leq t+1$, ${\tt pushable}(u_{i},v)\geq{\tt load}(A_{i},C^{\prime})$.

Proof:*   For a set of clients $B$, let $r(B)$ denote the sum of requests of the clients in $B$. For a node $v$, let $r(B,v)$ denote the sum of requests of the clients in $B$ that can access $v$, i.e., $r(B,v)=\sum_{a\in B:a\sim v}r(a)$.*

We identify the required set via a greedy procedure. Initialize $L=\emptyset$ and iterate over the nodes $u_{1},u_{2},\ldots,u_{t+1}$. For each node $u_{i}$, select $v_{i}={\rm argmax}_{v\in C-L}r(A_{i},v)$ and add $v_{i}$ to $L$.

Let $L$ be the set identified by the above procedure and let $C^{\prime}=C-L$. Fix any $i\leq t+1$. We derive a bound on ${\tt load}(A_{i},C^{\prime})$:

[TABLE]

The second statement follows from the LP constraint (3), whereas the third statement is by the definition of $r(A_{i},v)$. The fourth statement follows from the construction and the last statement follows from the bounded opening property.

For any client $a\in A_{i}$, the solution has opened a dedicated replica to an extent of $y(a)$ and the remaining assignment of $1-y(a)$ is going to the nodes. Our construction has ensured that $a$ is a small client and so $y(a)<1/2$. This means that the client $a$ is assigned to an extent of at least $1/2$ to the nodes in the cluster. Furthermore, the only nodes to which the client is assigned are $u_{i}$ and the nodes in the cluster $C$. Since $y(C)<1/4$, the total extent to which the client $a$ is assigned to the nodes in $C$ is less than $1/4$. This implies that $x(a,u_{i})\geq 1/4$. Therefore,

[TABLE]

*We have proved the lemma. *$\Box$

We have shown that each node $u_{i}$ has a load of at least ${\tt load}(A_{i},C^{\prime})$ which can be pushed to its consort $v_{i}$. As observed earlier ${\tt load}(A_{i},C^{\prime})<W/4$ and ${\tt load}(A_{i},v_{i})<W/4$. Hence, when we fully open the consort, we get an additional space of $(3/4)W$, which is sufficient to receive the load from $u_{i}$. The pseudo-code for processing a cluster $C$ is shown in Figure 5.

Given the above discussion, we iteratively consider each cluster $C_{j}\in{\cal C}$ and perform the above transformation. This results in $(t+1)$ consorts from $C_{j}$ being fully-opened and all the other nodes in $C_{j}$ being fully closed. At the end of processing all the clusters, we get a solution in which each node either fully open or fully close. For each cluster $C_{j}$, we incur an extra cost of at most $(t+1)$ while applying Proposition 5.1, and an additional cost of $(t+1)$ for opening the consorts. Thus, the cost increases by at most $2(t+1)|{\cal C}|$.

6 Integral Solution: Proof of Lemma 3.3

An integrally open solution falls short from being an integral solution in two aspects: (i) a client may be assigned to more than one node; (ii) a client may be served partly by a dedicated replica and partly by the network nodes. We address the first issue by appealing to Proposition 5.1 via taking $F$ to be the set of all fully open nodes and $A$ to be the problematic clients. In the resultant solution each client is assigned to at most one fully open node and the cost can increase by a factor of at most two. The second issue is addressed by the following proposition.

Proposition 6.1

Let $\sigma=\langle x,y\rangle$ be an integrally open solution in which each client is assigned to at most one node. It can be transformed into an integral solution $\sigma^{\prime}$ such that ${\rm cost}(\sigma^{\prime})\leq 2\cdot{\rm cost}(\sigma)$.

Proof:*   We iteratively consider each full open node $u$. Let $A\subseteq{\cal A}$ denote the clients assigned to $u$. Each client $a\in A$ is served partly by its own dedicated replica to an extent of $y(a)$, while the remaining request of $1-y(a)$ is assigned to $u$. We wish to obtain a solution wherein each at most one client is assigned to $u$. Suppose multiple clients are assigned to $u$. Choose any two such clients $a$ and $b$. Without loss of generality, assume that $r(a)\geq r(b)$. Let $\delta=\min\{x(a,u),y(b)\}$. Decrease $x(a,u)$ and $y(b)$ by $\delta$, and increase $y(a)$ and $x(b,u)$ by $\delta$. The assumption that $r(a)\geq r(b)$ ensures that the above transfers do not violate the capacity constraint at the node $u$. The transfer results in either $a$ or $b$ getting fully served by a dedicated replica and no longer being assigned to $u$. By repeating the process, we can derive a solution wherein at most one client $a$ is assigned to $u$. We then open a dedicated replica at the specified node $a$ and remove its assignment to $u$ (set $y(a)=1$ and $x(a,u)=0$). The procedure is repeated for all fully open nodes, leading to an integral solution $\sigma^{\prime}$. The cost increases by at most one unit for each full open node. Thus, ${\rm cost}(\sigma^{\prime})\leq 2\cdot{\rm cost}(\sigma)$. *$\Box$

We convert the input integrally open solution $\sigma$ in to an integral solution $\sigma^{\prime}$ by applying the above two steps. Each step incurs a $2$-factor increase in cost and thus, ${\rm cost}(\sigma^{\prime})$ is at most $4\cdot{\rm cost}(\sigma)$.