Storage Capacity as an Information-Theoretic Vertex Cover and the Index Coding Rate

TL;DR

This paper explores the storage capacity of graphs in distributed storage, relating it to vertex covers and index coding, providing approximation algorithms, exact characterizations for certain graph families, and extending to partial node failure recovery.

Contribution

It introduces a new information-theoretic perspective on storage capacity, develops approximation schemes, a gadget covering method, and extends the concept to partial failure scenarios.

Findings

Provides 3/2 approximation for planar graphs' storage capacity

Offers a polynomial-time approximation scheme for index coding rate with constant alphabet size

Derives exact storage capacity for cycles-with-chords graphs

Abstract

Motivated by applications in distributed storage, the storage capacity of a graph was recently defined to be the maximum amount of information that can be stored across the vertices of a graph such that the information at any vertex can be recovered from the information stored at the neighboring vertices. Computing the storage capacity is a fundamental problem in network coding and is related, or equivalent, to some well-studied problems such as index coding with side information and generalized guessing games. In this paper, we consider storage capacity as a natural information-theoretic analogue of the minimum vertex cover of a graph. Indeed, while it was known that storage capacity is upper bounded by minimum vertex cover, we show that by treating it as such we can get a 3/2 approximation for planar graphs, and a 4/3 approximation for triangle-free planar graphs. Since the storage capacity is intimately related to the index coding rate, we get a 2 approximation of index coding rate for planar graphs and 3/2 approximation for triangle-free planar graphs. We also show a polynomial time approximation scheme for the index coding rate when the alphabet size is constant. We then develop a general method of "gadget covering" to upper bound the storage capacity in terms of the average of a set of vertex covers. This method is intuitive and leads to the exact characterization of storage capacity for various families of graphs. As an illustrative example, we use this approach to derive the exact storage capacity of cycles-with-chords, a family of graphs related to outerplanar graphs. Finally, we generalize the storage capacity notion to include recovery from partial node failures in distributed storage. We show tight upper and lower bounds on this partial recovery capacity that scales nicely with the fraction of failures in a vertex.

Equations

$$\max H(X_1,\dots ,X_n)$$

$$H(X_i|X_{N(i)})=0,$$

$$\mathrm{Cap}(G)\equiv \underset{q}{\sup }{\mathrm{Cap}}_q(G).$$

$$\mathrm{Cap}(G)\le |\mathrm{VC}(G)|.$$

$$H(X_V)=H(X_{\mathrm{VC}(G)},X_{V\setminus \mathrm{VC}(G)})=H(X_{\mathrm{VC}(G)})+H(X_{V\setminus \mathrm{VC}(G)}|X_{\mathrm{VC}(G)})=H(X_{\mathrm{VC}(G)})\le |\mathrm{VC}(G)|.$$

$$\mathrm{MM}(G)\le {\mathrm{Cap}}_2(G)\le \mathrm{Cap}(G).$$

$$\min H(Y)$$

$$H(X_i|Y,X_{N(i)})=0,$$

$$\mathrm{Ind}(G)=\underset{q}{\inf }{\mathrm{Ind}}_q(G).$$

$$n-{\mathrm{Ind}}_q(G)\le {\mathrm{Cap}}_q(G)\le n-{\mathrm{Ind}}_q(G)+{\log }_q(n\ln q).$$

$$\mathrm{Cap}(G)=n-\mathrm{Ind}(G).$$

$$n-{\mathrm{Ind}}^{(q)}(G)\le {\mathrm{Cap}}^{(q)}(G)\le n-{\mathrm{Ind}}^{(q)}(G).$$

$$\mathrm{Ind}(G)\ge \alpha (G),$$

$$\sum _{C\in \mathcal{C}}{x}_C(|C|-1)$$

$$\sum _{C\in \mathcal{C}:u\in C}{x}_C\le 1\forall u\in V.$$

$$X_{u_{|C|}}^C=\sum _{i=1}^{|C|-1}{X}_{u_i}^C\mathrm{mod}{q}^{x_C}.$$

$$\prod _{i=1}^n{q}^{q^{d(i)}}\le q^{n{q}^{\Delta }},$$

$$O\left(\min \left\{1.1996^{q^n},m{q}^{n{q}^{\Delta }}\right\}\right)$$

$$1\le \frac{\mathrm{Cap}(G)}{\mathrm{CP}(G)}\le \frac{3t+k}{2t+3k/4}$$

$$\mathrm{Cap}(G)=H(X_V)=H(X_T)+H(X_C|X_T)+H(X_I|X_C,X_T)\le H(X_T)+H(X_C|X_T)\le 3t+k$$

$$\sum _{v\in I_1}{x}_v\ge \sum _{v\in I_2}{x}_v\ge \sum _{v\in I_3}{x}_v.$$

$$\sum _{u\in [n]}{y}_u\le \sum _{u\in I_2\cup I_3}{y}_u+\sum _{u\in [n]:x_u=1}{y}_u\le 2/3\cdot 2\cdot \sum _{u:x_u=1/2}{x}_u+\sum _{u:x_u=1}{x}_u\le 4/3\cdot \mathrm{CP}(G^{\prime }),$$

$$1\le \frac{n-\mathrm{CP}(G)}{\mathrm{Ind}(G)}\le \{\begin{array}{ll}\frac{3n+3t}{4n-12t}+\frac{3}{4}& \text{mbox}fort\le \frac{n}{12}\\ \frac{t}{n}+\frac{7}{4}& \text{mbox}for\frac{n}{12}\le t\le \frac{n}{4}\\ 4-\frac{8t}{n}& \text{mbox}fort\ge \frac{n}{4}\end{array}.$$

$$n-\mathrm{CP}(G)$$

$$=n-(2t+3/4(n-3t-\alpha (G^{\prime })))$$

$$=(n+t)/4+3/4\alpha (G^{\prime })$$

$$\mathrm{Ind}(G)\ge \alpha (G)\ge \alpha (G^{\prime })$$

$$\frac{n-\mathrm{CP}(G)}{\mathrm{Ind}(G)}$$

$${\mathrm{Cap}}_q(G)-k\le {\mathrm{Cap}}_q(G^{\prime })\le {\mathrm{Cap}}_q(G).$$

$$|V_0|$$

$${\mathrm{Cap}}_q(G)-n_0\le {\mathrm{Cap}}_q(G^{\prime })={\mathrm{Cap}}_q(G_1)+{\mathrm{Cap}}_q(G_2)+\dots$$

Full text

Keywords: Distributed storage, storage capacity, index coding, vertex cover, graph theory, approximation algorithms, planar graphs.

††footnotetext: College of Information and Computer Sciences, University of Massachusetts, Amherst. {arya,mcgregor,svorotni}@cs.umass.edu. This work was supported by NSF Awards CCF-0953754, IIS-1251110, CCF-1320719, CCF-1642658, CCF-BSF-1618512, and a Google Research Award. Some of the results of this paper have appeared in the proceedings of the IEEE International Symposium on Information Theory, 2017.

1 Introduction

The Shannon capacity of a graph [28] is a well studied parameter that quantifies the zero-error capacity of a noisy communication channel. There are also several other notions of graph capacities or graph entropies that model different communication/compression scenarios (for example, see [2]). In this paper, we are interested in a recent definition of graph capacity, called the storage capacity, that we consider to be a natural information-theoretic analogue of the minimum vertex cover of a graph.

Suppose, every vertex of a graph can store a symbol (from any alphabet) with the criterion that the content of any vertex can be uniquely recovered from the contents of its neighborhood in the graph. Then the maximum amount of information that can be stored in the graph is called the storage capacity of that graph [23]. This formulation is mainly motivated by applications in distributed storage, and generalizes the popular definition of locally repairable codes [17, 24, 14, 27]. In a distributed storage system, each symbol (or coordinate) of a codeword vector is stored at a different server or storage node. In the case of a single server failure, it is desirable to be able to recover the data of that server by accessing a small number of other servers. Given the topology of the storage network as a graph, it is quite natural to model the local repair problem as a neighborhood repair problem as above.

Formally, suppose we are given an $n$-vertex undirected graph $G(V,E)$, where $V=[n]\equiv\{1,2,\ldots,n\}$. Also, given a positive integer $q\geq 2$, let $H(X)$ be the Shannon entropy of the random variable $X$ in $q$-ary units (for example, when $q=2$, the entropy is in bits). Let $\{X_{i}\}_{i\in V}$, be random variables each with a finite sample space $Q$ of size $q$. For any $I\subseteq[n]$, let $X_{I}\equiv\{X_{i}:i\in I\}$. Consider the solution of the following optimization problem:

[TABLE]

such that

[TABLE]

for all $i\in V$ where $N(i)=\{j\in V:(i,j)\in E\}$ is the set of neighbors of vertex $i$. This is the storage capacity of the graph $G$ and we denote it by $\operatorname{Cap}_{q}(G)$. Note that, although we hide the unit of entropy in the notation $H(\cdot)$, the unit should be clear from context, and the storage capacity should depend on it, as reflected in the subscript in the notation $\operatorname{Cap}_{q}(G)$. The absolute storage capacity is defined to be,

[TABLE]

Note that, $H(X_{i}|X_{N(i)})=0$ in the above definition implies that there exist $n$ deterministic functions $f_{i}:Q^{|N(i)|}\to Q$ such that $f_{i}(X_{N(i)})=X_{i}$, $i=1,2,\dots,n.$ These functions are called the recovery functions. Given the recovery functions we can define a storage code $\{(x_{1},x_{2},\dots,x_{n})\in Q^{n}:x_{i}=f_{i}(x_{N(i)})\}.$ It follows that $\operatorname{Cap}_{q}(G)$ is the logarithm of the maximum possible size of a storage code over all possible sets of recovery functions.

In [23], it was observed that the storage capacity is upper bounded by the size of the minimum vertex cover $\operatorname{VC}(G)$ of the graph $G$.

[TABLE]

The proof of this fact is quite simple. Since all the neighbors of $V\setminus\operatorname{VC}$ belong to $\operatorname{VC}$,

[TABLE]

Indeed, this proof shows that $H(X_{V})=H(X_{\operatorname{VC}(G)})$. Because of this, we think it is natural to view storage capacity as an information theoretic analogue of vertex cover. It was also shown in [23] that the storage capacity is at least equal to the size $\operatorname{MM}(G)$ of the maximum matching of the graph $G$:

[TABLE]

Since maximum matching and minimum vertex cover are two quantities within a factor of two of each other and maximum matching can be found in polynomial time, this fact gives a $2$-approximation of the storage capacity111Indeed, finding a maximal matching is sufficient for this purpose.. Provable strict improvement of the maximum matching scheme is unlikely to be achieved by simple means, since that would imply a better-than-2 approximation ratio for the minimum vertex cover problem violating the unique games conjecture [20].

This motivates us to look for natural families of graphs where minimum vertex cover has a better approximation. For example, for bipartite graphs maximum matching is equal to minimum vertex cover and hence storage capacity is exactly equal to the minimum vertex cover. Another obvious class, and our focus in Section 4, is the family of planar graphs for which a PTAS (polynomial-time-approximation-scheme) is known [7, 6]. Another motivation for studying storage capacity on planar graphs is that they represent common network topologies for distributed systems. For example, see [13] to note how a surprising number of data networks are actually planar. To minimize interference, it is natural for a distributed storage system to be arranged as a planar network. Moreover it is useful to have wireless networks, video-on-demand networks etc. that are planar or almost planar.

Video-on-demand also motivates a related broadcast problem called index coding [8] for which planar topologies are of interest, and outerplanar topologies have already been studied [9]. It was shown in [23] that storage capacity is, in a coding-theoretic sense, dual to index coding and is equivalent to the guessing game problem of [16]. Let $\{X_{i}\}_{i\in V}$ be independent uniform random variables each with a finite sample space of size $q$. The index coding rate for a graph $G(V,E)$ is defined to be the optimum value of the following minimization problem:

[TABLE]

where $Y$ is a random variable with finite support such that

[TABLE]

for all $i\in V$. This is called the optimum index coding rate for the graph $G$, and we denote it as $\operatorname{Ind}_{q}(G)$. We can also define,

[TABLE]

The index coding problem is the hardest of all network coding problems and has been the subject of much recent attention, see, e.g., [21]. In particular it can be shown that any network coding problem can be reduced to an index coding problem [15]. It has been shown that (see [23]),

[TABLE]

From this we claim,

[TABLE]

To see this, define $\operatorname{Cap}^{(q)}(G)\equiv\sup_{m\in{\mathbb{Z}}_{+}}\operatorname{Cap}_{q^{m}}(G)$ and $\operatorname{Ind}^{(q)}(G)\equiv\inf_{m\in{\mathbb{Z}}_{+}}\operatorname{Ind}_{q^{m}}(G)$. It is evident that $(m+r)\operatorname{Cap}_{q^{m+r}}(G)\geq m\operatorname{Cap}_{q^{m}}(G)+r\operatorname{Cap}_{q^{r}}(G)$ and $(m+r)\operatorname{Ind}_{q^{m+r}}(G)\leq m\operatorname{Ind}_{q^{m}}(G)+r\operatorname{Ind}_{q^{r}}(G)$ for any two nonnegative integers $m$ and $r$. Therefore, using Fekete’s lemma, $\operatorname{Cap}^{(q)}(G)=\lim_{m\to\infty}\operatorname{Cap}_{q^{m}}(G)$ and $\operatorname{Ind}^{(q)}(G)=\lim_{m\to\infty}\operatorname{Ind}_{q^{m}}(G)$. Now this gives, from (7),

[TABLE]

Taking supremum on both sides we have, $\operatorname{Cap}(G)=n-\operatorname{Ind}(G)$.

Hence, exact computation of $\operatorname{Ind}(G)$ and $\operatorname{Cap}(G)$ is equivalent although the approximation hardness could obviously differ. Note that,

[TABLE]

where $\alpha(G)$ is the independence number of $G$. Since, for planar graphs $\alpha(G)\geq n/4$, taking $Y$ to be $X_{[n]}$ already gives a $4$-approximation for the index coding rate for planar graphs since $H(Y)\leq n$ [5]. In this paper, we give a significantly better approximation algorithm for index coding rate of planar graphs. Not only that, due to the relation between index coding rate and storage capacity, we can obtain an approximation factor significantly better than $2$ for storage capacity. Note that, for general graphs even to approximate the optimal index coding rate within a factor of $n^{1-\epsilon}$ seems to be a challenge [12].

To go beyond the realm of planar graphs, and to obtain better approximation ratios, we then develop several upper bounding tools for storage capacities. In particular by using these tools, we are able to exactly characterize storage capacities of various families of graphs. Our approach revisits a linear program proposed by Blasiak, Kleinberg, and Lubetzky [11] that can be used to lower bound the optimum index coding rate or upper bound the storage capacity. We transform the problem of bounding this LP into the problem of constructing a family of vertex covers for the input graph. This in turn allows us to upper bound the storage capacity of any graph that admits a specific type of vertex partition. We then identify various graphs for which this upper bound is tight.

Since, the storage capacity, or the vertex cover, act as absolute upper bounds on the rate of information storage in the graph, a natural question to ask is, if we store above the limit of minimum vertex cover in the graph, will any of the repair property be left? This is similar in philosophy to the rate-distortion theory of data compression, where one compresses beyond entropy limit and still can recover the data with some distortion. This question gives rise to the notion of recovery from partial failure, as defined below.

We define the partial repair capacity also keeping the application of distributed storage in mind. This is a direct generalization in the context of distributed storage application to handle partial failure of vertices. In particular, suppose we lose $0\leq\delta\leq 1$ proportion of the bits stored in a vertex. We still want to recover these bits by accessing the remaining $(1-\delta)$-fraction of the bits in the vertex plus the contents of the neighborhood. What is the maximum amount of information that can be stored in the network with such restriction? Intuitively, the storage capacity should increase. We characterize the trade-off between $\delta$ and this increase in storage capacity from both sides (i.e., upper and lower bounds on the capacity). A surprising fact that we observe is that, if we want to recover from more than half of the bits being lost, then there is no increase in storage capacity.

In summary, we made progress on the study of storage capacity on three fronts:

• •

Planar graphs. We prove a $3/2$ approximation of absolute storage capacity and $2$ approximation for index coding rate for planar graphs. We provide an approximation guarantee that depends on the number of triangles in the graph and, in the special case of triangle-free graphs, we get a $4/3$ approximation for storage capacity, and $3/2$ approximation for index coding rate. In addition to this, for a constant-size $q$ alphabet, we give a polynomial-time approximation scheme (PTAS) or an $(1+\epsilon)$ approximation, $\epsilon>0,$ for $\operatorname{Ind}_{q}(G)$ of planar graphs using the well-known planar separator theorem [22].

• •

Tools for finding storage capacity upper bounds. We develop an approach for bounding storage capacity in terms of a small number of vertex covers. We first illustrate this approach by finding the exact storage capacity of some simple graphs. We then use the approach to show a bound on any graph that admits a specific type of vertex partition. With this we prove exact bounds on a family of Cartesian product graphs and a family closely related to outerplanar graphs.

• •

Partial failure recovery. We show that if recovery from neighbors is possible for up to $\delta$-proportion failure of the bits stored in a server, then the capacity is upper bounded by the optimum value of a linear program; in particular this implies when $\delta\geq\frac{1}{2}$, then the partial recovery capacity is same as the storage capacity. For an odd cycle, the upper bound on partial recovery capacity is given by $\frac{n}{2}(1+R_{2}(\delta))$, where $R_{2}(\delta)$ is the maximum achievable rate of a binary error-correcting code with relative minimum Hamming distance at least $\delta n$. On the other hand, we also obtain general lower bounds on the partial recovery capacity of a graph. For an odd cycle, our results imply that a partial failure recovery capacity of $\frac{n}{2}(2-h_{2}(\delta))$ is polynomial time achievable, where $h_{2}(\delta)$ denotes the binary entropy function. Our bounds are likely to be tight, since it is a widely believed conjecture that $R_{2}(\delta)=1-h_{2}(\delta)$ (the Gilbert-Varshamov bound).

Organization.

The remainder of the paper is organized as follows. In Sections 2 and 3 we state and prove some preliminary algorithmic results regarding the storage capacity and index coding that will be useful in proving subsequent results. In section 4, we prove our approximation results for planar graphs that include a $3/2$ approximation for $\operatorname{Cap}(G)$, $2$ approximation for $\operatorname{Ind}(G)$ and a PTAS for $\operatorname{Ind}_{q}(G)$. In Section 5, we show a vertex partition approach to upper bound the storage capacity. The results regarding recovery from partial node failure are described in Section 6.

2 Preliminaries

Let $\operatorname{CP}(G)$ denote the fractional clique packing of a graph $G(V,E)$ defined as follows: Let ${\mathcal{C}}$ be the set of all cliques in $G$. For every $C\in{\mathcal{C}}$ define a variable $0\leq x_{C}\leq 1$. Then $\operatorname{CP}(G)$ is the maximum value of

[TABLE]

subject to the constraint that

[TABLE]

Note that $\operatorname{CP}(G)$ can be computed in polynomial time in graphs, such as planar graphs, where all cliques have constant size. Furthermore, $\operatorname{CP}(G)$ is at least the size of the maximum fractional matching and they are obviously equal in triangle-free graphs since the only cliques are edges.

The following preliminary lemma shows that $\operatorname{Cap}_{q}(G)\geq\operatorname{CP}(G)$ for sufficiently large $q$. An equivalent result is known in the context of index coding but we include a proof here for completeness. The basic idea is that we can store $k-1$ units of information on a clique of size $k$ by assigning $k-1$ independent uniform random variables to $k-1$ of the vertices and setting the final random variable to the sum (modulo $q$) of the first $k-1$ random variables.

Lemma 1**.**

$\operatorname{Cap}_{q}(G)\geq\operatorname{CP}(G)$* for sufficiently large $q$.*

Proof.

Let $\{x_{C}\}_{C\in{\mathcal{C}}}$ achieve $\operatorname{CP}(G)$. Let $q$ be sufficiently large power of $2$ such that ${x_{C}}\cdot\log_{2}q$ is integral for every $C$. For each clique $C=\{u_{1},\ldots,u_{|C|}\}$ in the graph, define a family of random variables $X_{u_{1}}^{C},X_{u_{2}}^{C},\ldots,X_{u_{|C|}}^{C}$ where $X_{u_{1}}^{C},X_{u_{2}}^{C},\ldots,X_{u_{|C|-1}}^{C}$ are independent and uniform over $\{0,1,\ldots,q^{x_{C}}-1\}$ and

[TABLE]

Note that each $X_{u_{i}}^{C}$ can be deduced from $\{X_{u_{j}}^{C}\}_{j\neq i}$ and the entropy of $\{X_{u_{j}}^{C}\}_{j\neq i}$ is $x_{C}(|C|-1)$. Finally, let $X_{u}$ be an encoding of $\{X_{u}^{C}\}_{C\in{\mathcal{C}}:u\in C}$ as a symbol from a $q$-ary alphabet; the fact that this is possible follows because $\sum_{C\in{\mathcal{C}}:u\in C}x_{C}\leq 1$. Then the entropy of $\{X_{u}\}_{u\in V}$ is $\operatorname{CP}(G)$ as required. ∎

Further notations.

Let $G[S]$ denote the subgraph induced by $S\subseteq V$. Let $\operatorname{\alpha}(G)$ be the size of the largest independent set and let $\operatorname{VC}(G)$ be the size of minimum vertex cover. Let $\operatorname{MM}(G)$ be the size of the largest matching of the graph and let $\operatorname{FM}(G)$ be the weight of the maximum fractional matching, i.e., $\operatorname{FM}(G)$ is the maximum of $\sum_{e\in E}x_{e}$ such that $\sum_{e:v\in E}x_{e}\leq 1$ for all $v\in V$ and $0\leq x_{e}\leq 1,\forall e\in E.$

3 Exact algorithms for storage capacity and index coding rate

In this section, we describe some (super)exponential time algorithms that compute $\operatorname{Cap}_{q}(G)$ and $\operatorname{Ind}_{q}(G)$ exactly for a constant $q$. First, we review the approach involving a confusion graph and then present another algorithm for storage capacity that has faster running time on some graphs.

Let the vertices of the graph $G$ be represented by $1,2\dots,n$. A confusion graph $\mathcal{G}(G)$ of $G$ has $q^{n}$ vertices. Each of the different $q$-ary strings of length $n$ represent the vertices. There is an edge between two strings $x$ and $y$ if there exists some $i\in\{1,\dots,n\}$, such that $x_{i}\neq y_{i}$, but $x_{j}=y_{j}$ for all $j\in N(i),$ neighbors of $i$ in $G$. It is known that the index coding rate $\operatorname{Ind}_{q}(G)$ is equal to logarithm of the chromatic number of $\mathcal{G}(G)$ and the storage capacity $\operatorname{Cap}_{q}(G)$ is the logarithm of the size of maximum independent set of $\mathcal{G}(G)$ [1, 23]. Thus, by employing the best currently known algorithms for computing chromatic number [10] and maximum independent set [29], we can compute $\operatorname{Ind}_{q}(G)$ and $\operatorname{Cap}_{q}(G)$ in time $O(2.2461^{q^{n}})$ and $O(1.1996^{q^{n}})$ respectively.

To compute storage capacity $\operatorname{Cap}_{q}(G)$, we can take a different approach. We can go over all the possibilities for the $n$ recovery functions $f_{1},\dots,f_{n}$ corresponding to vertices $1,2,\dots,n$, and for each of the possibilities construct the corresponding storage codes. To be precise, let vertex $i\in[n]$ have degree $d(i)$. There are $q^{q^{d(i)}}$ possibilities for the recovery function $f_{i}$. The total number of possibilities for $n$ recovery functions is then

[TABLE]

where $\Delta$ is the maximum degree in $G$. For each possibility, we go over the $q^{n}$ vectors and remove the ones that do not agree with the recovery functions, which takes time $O(m)$, where $m=\frac{1}{2}\sum_{v\in V(G)}d(v)$ is the number of edges in $G$, per vector. The remainder of the vectors form the storage code that agrees with the recovery functions. We find the combination of recovery functions that give the largest storage code. The total running time of this algorithm is at most $O(mq^{n}q^{nq^{\Delta}})$. Since without loss of generality we can assume that the largest storage code contains the all-zero vector, the running time can slightly be improved to $O(mq^{nq^{\Delta}})$. If $\Delta$ is small then this approach is faster than building a confusion graph and computing maximum independent set on it.

To summarize, we have the following result that will be used to design a PTAS for $\operatorname{Ind}_{q}(G)$ for planar graphs.

Theorem 2**.**

Computing $\operatorname{Cap}_{q}(G)$ exactly takes time

[TABLE]

for a graph with $n$ vertices, $m$ edges, and maximum degree $\Delta$. Computing $\operatorname{Ind}_{q}(G)$ exactly takes time $O(2.2461^{q^{n}})$.

4 Approximation algorithms for planar graphs via vertex cover

In this section, we present approximation results for the storage capacity and optimal index coding rate of planar graphs. Specifically we show that $\operatorname{CP}(G)$ can be used to achieve a $3/2$ approximation of the storage capacity and a $2$ approximation of the optimal index coding rate.

In our storage capacity result we use ideas introduced by Bar-Yehuda and Even[7] for the purpose of $5/3$-approximating the vertex cover in planar graphs. Specifically, they first considered a maximal set of vertex-disjoint triangles, reasoned about the vertex cover amongst these triangles, and then reasoned about the triangle-free induced subgraph on the remaining vertices. We consider a similar decomposition and reason about the integrality gap of vertex cover in each component. We parameterize our result in terms of the number of triangles; this will be essential in the subsequent result on optimal index coding rate.

Theorem 3**.**

Assume $G$ is planar and let $T$ be a set of $3t$ vertices corresponding to maximal set of $t$ vertex disjoint triangles. Then,

[TABLE]

where $k$ is the size of the minimum vertex cover of $G[V\setminus T]$. Hence $\operatorname{CP}(G)$ is a $3/2$ approximation for $\operatorname{Cap}(G)$ and $4/3$ approximation if $G$ is triangle-free.

Proof.

Let $G^{\prime}=G[V\setminus T]$. Partition the set of vertices $V$ into $T\cup C\cup I$ where $C$ is the minimum vertex cover of $G^{\prime}$ and $I\subset V\setminus T$ is therefore an independent set. Let $X_{V}$ be the set of variables that achieve storage capacity. Therefore,

[TABLE]

since for each $v\in I$, $H(X_{v}|X_{C},X_{T})=0$ since $N(v)\subset C\cup T$.

Consider the fractional clique packing in which each of the $t$ vertex-disjoint triangles in $T$ receive weight $1$. Then, $\operatorname{CP}(G)\geq 2t+\operatorname{CP}(G^{\prime})$. Then it remains to show that $\operatorname{CP}(G^{\prime})\geq 3k/4$. Note that since $G^{\prime}$ is triangle-free planar graph, it is 3-colorable by Grötzsch’s theorem [18]. Furthermore, $\operatorname{CP}(G^{\prime})$ is the maximum fractional matching which, by duality, is the minimum fractional vertex cover. Hence it suffices to show that the size of the minimum fractional vertex cover of a 3-colorable graph is at least $3/4$ of the size of the minimum (integral) vertex cover, i.e., $3k/4$. This can be shown as follows. Let $x_{1},\ldots,x_{n}$ be an optimal fractional vertex cover, i.e., for all edges $uv\in G^{\prime}$, $x_{u}+x_{v}\geq 1$. Since fractional vertex cover is $1/2$-integral (i.e., there exists an optimal solution where each variable is either integral or $1/2$) [19], we may assume each $x_{u}\in\{0,1/2,1\}$. Let $I_{1},I_{2},I_{3}$ be a partitioning of $\{u\in[n]:x_{u}=1/2\}$ corresponding to a 3-coloring where

[TABLE]

Then consider $y_{1},\ldots,y_{n}$ where $y_{u}=1$ iff $u\in I_{2}\cup I_{3}$ or $x_{u}=1$. Then

[TABLE]

and $y_{1},\ldots,y_{n}$ is a vertex cover because for every edge $uv$, at least one endpoint one of $\{x_{u},x_{v}\}$ is 1 or at least one of $u$ and $v$ is in $I_{2}\cup I_{3}$. ∎

We next use the result of the previous theorem, together with the chromatic number of planar and triangle-free planar graphs to achieve a $2$ approximation for $\operatorname{Ind}(G)$.

Theorem 4**.**

Assume $G$ is planar and let $T$ be a set of $3t$ vertices corresponding to $t$ vertex disjoint triangles. Then,

[TABLE]

Maximizing over $t$ implies that $n-\operatorname{CP}(G)$ is a $2$ approximation for $\operatorname{Ind}(G)$ and a $3/2$ approximation if $G$ is triangle-free.

Proof.

From Theorem 3, we know that $\operatorname{CP}(G)\geq 2t+3/4\operatorname{VC}(G^{\prime})$ where $G^{\prime}=G[V\setminus T]$. Therefore, we can bound $n-\operatorname{CP}(G)$ as follows:

[TABLE]

On the other hand,

[TABLE]

where $\operatorname{\alpha}$ denotes the size of the maximum independent set of the graph. Note that $\operatorname{\alpha}(G)\geq n/4$ since $G$ is planar and thus 4-colorable [4, 3]. Since $G^{\prime}$ has $n-3t$ vertices and is triangle-free and planar and thus 3-colorable [18], $n-3t\geq\operatorname{\alpha}(G^{\prime})\geq(n-3t)/3$. By combining inequalities above we get

[TABLE]

∎

4.1 Approximation algorithms for fixed alphabet size

In this section, we present improved polynomial time algorithms for approximating the storage capacity and the index coding rate on the assumption that the alphabet size $q$ of the codes is a fixed constant. These are based on combining the exact algorithm described in Section 3 with the planar separator theorem [22].

Lemma 5**.**

Let $G^{\prime}$ be a graph formed by removing at most $k$ vertices from $G$. Then,

[TABLE]

Proof.

Consider an optimal storage code and fix the value of the $k$ vertices to their most common $k$-tuple of values. This decreases the size of the code by at most a factor $q^{k}$ and hence decreases the storage capacity by at most $k$. The fact that $\operatorname{Cap}_{q}(G^{\prime})\leq\operatorname{Cap}_{q}(G)$ follows because any code for $G^{\prime}$ is also a code for $G$. ∎

The following lemma shows that the removal of a relatively small number of vertices in a planar graph is sufficient to ensure that the remaining components are small. The proof is essentially the same as that used to establish Theorem 3 in [22].

Lemma 6**.**

There exists $n_{0}\leq\epsilon n$ vertices $V_{0}$ in a planar graph whose removal yields a graph with at most $r=O(\epsilon^{2}n)$ components $G_{1},G_{2},\ldots,G_{r}$ where each $G_{i}$ has $n_{i}=O(1/\epsilon^{2})$ vertices and there are no edges between $G_{i}$ and $G_{j}$. Furthermore, $V_{0}$, $G_{1},G_{2},\ldots$ can by found in polynomial time.

Proof.

The planar separator theorem [22] states that in any planar graph there exists a set of at most $c\sqrt{n}$ vertices (for some large constant $c$) such that the removal of these vertices disconnects the graph into components of size at most $2n/3$. Furthermore, these vertices can be found in polynomial time. Consider applying this recursively on all components until they each have size less than $\alpha c^{2}/\epsilon^{2}$ for a sufficiently large constant $\alpha>1$ . Then, the total number of vertices removed is at most

[TABLE]

because, during the course of the recursion, the planar separator theorem is applied to at most $n/((2/3)^{i}n)$ graphs of size between $(2/3)^{i}n$ and $(2/3)^{i-1}n$ and each such application involves the removal of at most $c\sqrt{(2/3)^{i-1}n}$ vertices. ∎

Theorem 7**.**

There exists polynomial time algorithms to approximate $\operatorname{Ind}_{q}(G)$ up to a multiplicative factor of $1+\epsilon$ and approximate $\operatorname{Cap}_{q}(G)$ up additive error $\epsilon n$.

Proof.

The result for $\operatorname{Cap}_{q}(G)$ follows by applying the decomposition in Lemma 6 to $G$ and then solving the problem optimally on $G_{1},G_{2},\ldots$ using the algorithm in Section 3. Let $G^{\prime}=G_{1}\cup G_{2}\cup\ldots$. By Lemma 5,

[TABLE]

and hence finding the optimal solution for each $\operatorname{Cap}_{q}(G_{i})$ yields an additive $n_{0}\leq\epsilon n$ approximation as required.

The result for $\operatorname{Ind}_{q}(G)$ is similar. By using the results in Section 3, we can find the optimal index coding solution of each $G_{i}$. Combining these with the naive solution for the $n_{0}$ vertices in $V_{0}$ yields a solution with rate $n_{0}+\sum_{i\geq 1}\operatorname{Ind}_{q}(G_{i})$. We can relate $\operatorname{Ind}_{q}(G)$ to this as follows:

[TABLE]

where the last line follows since $\operatorname{Ind}_{q}(G)\geq n/4$, $n_{0}\leq\epsilon n$, $r=O(\epsilon^{2}n),n_{i}=O(\epsilon^{-2})$. Reparamaterizing by $\epsilon\leftarrow\epsilon/c$ for some sufficiently large constant gives the required result. ∎

5 Upper Bounds on Storage Capacity via Multiple Vertex Covers

In this section, we start by considering a linear program proposed by Blasiak, Kleinberg, and Lubetzky [11] that can be used to lower bound the optimum index coding rate or upper bound the storage capacity.222Blasiak et al. only consider index coding but it is straightforward to adapt the LP in a natural way for storage capacity; see below. Unfortunately there are $\Omega(2^{n})$ constraints but by carefully selecting a subset of constraints we can prove upper bounds on the storage capacity for a specific graph without solving the LP.

Our main goal in this section is to relate this linear program to finding a suitable family of vertex covers of the graph. In doing so, we propose a combinatorial “gadget” based approach to constructing good upper bounds that we think makes the process of proving strong upper bounds more intuitive. This allows us to prove a more general theorem that gives an upper bound on the storage capacity for a relatively large family of graphs. As an application of this theorem we show that a class of graphs closely related to the family of outerplanar graphs and another family of cartesian product graphs have capacity exactly $n/2$.

5.1 Upper Bound via the “Information Theoretic” LP

We first rewrite the index coding LP proposed by Blasiak, Kleinberg, and Lubetzky [11] for the purposes of upper-bounding storage capacity. We define a variable $z_{S}$ for every $S\subseteq V$ that will correspond to an upper bound for $H(X_{S})$. Let $\operatorname{cl}(S)=S\cup\{v:N(v)\subseteq S\}$ denote the closure of the set $S$ consisting of vertices in $S$ and vertices with all neighbors in $S$.

[TABLE]

The second constraint corresponds to

[TABLE]

whereas the last constraint follows from the sub-modularity of entropy. Hence, the optimal solution to the above LP is an upper bound on $\operatorname{Cap}(G)$. We henceforth refer to the above linear program as the information theoretic LP.

5.2 Upper Bound via Gadgets

$k$-cover by gadgets is a technique for proving upper bounds on the storage capacity of a graph. The core idea is to construct a set of $k$ vertex covers for the graph via the construction of various gadgets which we now define.

A gadget $g=(S_{1},S_{2},c_{1},c_{2})$ consists of two special sets of vertices $S_{1}$ and $S_{2}$ and two colors $c_{1}$ and $c_{2}$. Sets $S_{1}$ and $S_{2}$ are created in the following way: take two sets of vertices $A$ and $B$, take their closures $\operatorname{cl}(A)$ and $\operatorname{cl}(B)$, then $S_{1}=\operatorname{cl}(A)\cup\operatorname{cl}(B)$ and $S_{2}=\operatorname{cl}(A)\cap\operatorname{cl}(B)$. Call $S_{1}$ the outside of the gadget and $S_{2}$ its inside, as it is always the case that $S_{1}\supseteq S_{2}$. We note that by taking $A=\{v\}$ and $B=\emptyset$ we obtain a gadget with the outside $\{v\}$ and empty inside (assuming $v$ has no neighbors of degree one); call such gadget trivial. Define the weight of a gadget to be $w(g)=|A|+|B|$. As for the two colors of the gadget, they are picked from a fixed set of $k$ colors; $c_{1}$ is assigned to all vertices in $S_{1}$ and $c_{2}$ is assigned to all vertices in $S_{2}$. Note, that a vertex can be assigned multiple colors in that manner. The objective is to find a set of gadgets, such that for any color $c$, vertices with $c$ assigned to them form a vertex cover. If that condition is met for all $k$ colors, we show that the total weight of the gadgets used provides an upper bound on $k\operatorname{Cap}(G)$.

We can formulate the $k$-cover by gadgets (for fixed $k$) as the following integer linear program: Let $x_{g,S}$ be a variable where vertex set $S$ is a part of gadget $g$. Note that there are two variables per gadget, corresponding to its outside and inside sets. $x_{g,S}=1$ if $g$ participates in the cover by gadgets and 0 otherwise. We use $c_{g}(S)=c$ to denote that the color of vertex set $S$ in gadget $g$ is $c$.

[TABLE]

The first condition states that the union of sets of a certain color is a vertex cover and the second one states that both the inside and outside of $g$ participate (or do not participate) in the gadget cover.

Theorem 8**.**

Any feasible integral solution to the above $k$-cover by gadgets integer LP is an upper bound on $\operatorname{Cap}(G)$.

Proof.

We prove this by considering the information theoretic LP above and showing how to bound $z_{V}$ by the gadget weights. First, note which constraints correspond to the steps of creating a gadget:

[TABLE]

If we sum all the constraints, we obtain $z_{S_{1}}+z_{S_{2}}\leq|A|+|B|$. Recall that $|A|+|B|$ is the weight of the gadget. Let $H$ be a cover by gadgets. Then by summing all corresponding constraints, we get

[TABLE]

Group the sets participating in gadgets in $H$ into color classes $C_{1},C_{2},\dots,C_{k}$. Let $U_{i}=\bigcup\limits_{S\in C_{i}}S$ be the set of all vertices of color $c_{i}$. The corresponding constraints are then

[TABLE]

Note that $z_{V}=z_{cl(U_{i})}$ since $U_{i}$ is a vertex cover. By summing these $2k$ constraints and the one obtained from building gadgets, we get $kz_{V}\leq\sum_{g\in H}w(g)$. ∎

5.2.1 Examples

We next illustrate the use of the $k$-cover via gadgets approach with a couple of examples. First, we use a 2-cover by gadgets to re-prove a result of Blasiak et al. [12] that established that the storage capacity of a cycle on $n$ vertices is $n/2$. The point of this first example is to illustrate simplicity of the new approach. Then we give an example of an outerplanar graph for which we establish a tight bound of 14/3. In addition to serving as another example of the new approach, we think this example is particularly interesting as it demonstrates that it is sometimes necessary to consider a $k$-cover via gadgets where $k>2$ in order to establish a tight result. Note that any upper bound via a $k$-cover via gadgets is a multiple of $1/k$ and hence $k=1$ or $k=2$ would be insufficient to prove a tight bound of 14/3.

Odd Cycles.

We prove that the storage capacity of an odd cycle of length $n$ is $n/2$; see Figure 1(a) for an example where $n=9$. $\operatorname{FM}(C_{n})=n/2$, thus $\operatorname{Cap}(C_{n})\geq n/2$. For the upper bound we create a gadget by taking $A=\{v_{1},v_{3}\}$, $B=\{v_{2},v_{4}\}$ and obtaining outside set $S_{1}=\{v_{1},v_{2},v_{3},v_{4}\}$ and inside set $S_{2}=\{v_{2},v_{3}\}$. On the rest of the vertices we place trivial gadgets. Color $S_{1}$ and trivial gadgets on $v_{6},v_{8},\dots,v_{n-1}$ green, color $S_{2}$ and trivial gadgets on $v_{5},v_{7},\dots,v_{n}$ red. Green and red sets are then vertex covers and the total weight of all gadgets is $n$. Thus, $\operatorname{Cap}(C_{n})\leq n/2$.

An Outerplanar Graph.

We prove that the storage capacity of the graph in Figure 1(b) is $14/3$. This capacity is achieved by the fractional clique cover. Create gadget $g_{1}$ from $A_{1}=\{v_{1},v_{3}\}$ and $B_{1}=\{v_{2},v_{4}\}$ and another gadget $g_{2}$ from $A_{2}=\{v_{5},v_{7}\}$ and $B_{2}=\{v_{6},v_{8}\}$. Place one trivial gadget on each of the vertices $v_{2},v_{4},v_{5},v_{7}$ and 2 trivial gadgets on $v_{9}$. The sets are colored as follows:

• •

Red: $v_{5},v_{7},v_{9}$ and the inside of gadget $g_{1}$

• •

Blue: $v_{2},v_{4},v_{9}$ and the inside of gadget $g_{2}$

• •

Green: the outside sets of both $g_{1}$ and $g_{2}$

Note that vertices of every color class form a vertex cover and the total weight of gadgets is $14$.

5.3 $n/2$ Upper Bound via Vertex Partition

The next theorem uses a $2$-cover by gadgets to prove that a certain family of graphs have capacity at most $n/2$. Subsequently, we will use this theorem to exactly characterize the capacity of various graph families of interest.

Theorem 9**.**

Suppose that the vertices of a graph $G$ can be partitioned into sets $X$ and $Y$ such that:

$G[X]$* and $G[Y]$ are both bipartite.* 2. 2.

$S_{X}$* is an independent set in $G[X]$ and $S_{Y}$ is an independent set in $G[Y]$*

where $S_{X}\subseteq X$ consists of all vertices in $X$ with a neighbor in $Y$ and $S_{Y}\subseteq Y$ consists of all vertices in $Y$ with a neighbor in $X$. Then $\operatorname{Cap}(G)\leq n/2$.

Proof.

We prove this theorem by showing that $G$ has a 2-cover by gadgets of total weight $n$. Let $(A,B)$ be a bipartition of the vertices of $G[X]$. Create the sets of gadget $g_{X}$ from $A$ and $B$. Note that the vertices in $X$ that are in the outside set of the gadget but not in the inside set, are exactly the vertices in $S_{X}$. This follows because for $v\in X$, $v\in\operatorname{cl}(A)\cap\operatorname{cl}(B)$ iff all of $v$’s neighbors are in $X$. Similarly, create $g_{Y}$. Color the inside of $g_{X}$ and the outside of $g_{Y}$ red. Color the outside of $g_{X}$ and the inside of $g_{Y}$ blue. Observe that both color classes are vertex covers and the total weight of the 2 gadgets is $|X|+|Y|=n$. ∎

5.3.1 Cartesian Product of a Cycle and a Bipartite Graph

We now illustrate an application of Theorem 9. The Cartesian product of graphs $G_{1}=(V_{1},E_{1})$ and $G_{2}=(V_{2},E_{2})$ is denoted by $G_{1}\square G_{2}$ and defined as follows:

• •

The vertex set is the Cartesian set product $V_{1}\times V_{2}$

• •

$(u,u^{\prime})(v,v^{\prime})$ is an edge iff $u=v$ and $u^{\prime}v^{\prime}\in E_{2}$ or $u^{\prime}=v^{\prime}$ and $uv\in E_{1}$

We next use Theorem 9 to show that any Cartesian Product of a cycle and a bipartite graph has storage capacity exactly $n/2$. An example of such a graph is given in Fig. 2 where the bipartite graph considered is just a length 3 path.

Theorem 10**.**

Let $C_{k}$ be a cycle with $k>3$, $B$ a bipartite graph, and $G=C_{k}\square B$. Then $\operatorname{Cap}(G)=n/2$, where $n$ is the number of vertices in $G$.

Proof.

If $k$ is even, $G$ is a bipartite graph with $\operatorname{MM}(G)=\operatorname{VC}(G)=n/2$ and hence $\operatorname{Cap}(G)=n/2$. Assume for the rest of the proof that $k$ is odd.

To show that $\operatorname{Cap}(G)\geq n/2$, consider the fractional matching where we assign weight $1/2$ to all edges of the form $(u,a)(v,a)$, i.e., edges that come from the cycle. Hence $\operatorname{Cap}(G)\geq n/2$.

To show that $\operatorname{Cap}(G)\leq n/2$ we proceed as follows. Consider the subgraph $G_{i}$ induced by vertices $(u_{i},v_{1})$, $(u_{i},v_{2})$, $(u_{i},v_{3})$, etc., which is isomorphic to $B$. Fix a bipartition $(R,Q)$ of $B$ and split the vertices of each $G_{i}$ into $R_{i}$ and $Q_{i}$ according to that bipartition. We now show that $X=R_{1}\cup Q_{2}$ and $Y=V\setminus X$ satisfy the conditions of Theorem 9. $G[X]$ has no edges and therefore is bipartite. $G[Y]$ is bipartite because it consists of $P_{k-3}\square B$ which is bipartite (where $P_{k-3}$ is a path of length $k-3$ obtained by deleting edges $u_{k}u_{1}$, $u_{1}u_{2}$, and $u_{2}u_{3}$ from the cycle), edges between $R_{k}$ and $R_{1}$, and edges between $Q_{2}$ and $Q_{3}$ which do not complete any cycles. $S_{X}=X$ is an independent set. $S_{Y}=R_{k}\cup Q_{1}\cup R_{2}\cup Q_{3}$ is also an independent set. ∎

5.3.2 Cycles With Chords That Are Not Too Close Together

We next apply Theorem 9 to prove that a family of graphs related to outerplanar graphs also has storage capacity $n/2$. Recall that any (connected) outerplanar graph without cut vertices is a cycle with non-overlapping chords. The family of graphs we consider is more general in the sense that we permit the chords to overlap but more restrictive in the sense that we require the endpoints of these chords to be at least a distance 4 apart on the cycle. A natural open question is to characterize $\operatorname{Cap}(G)$ for all outerplanar graphs. All that was previously known is that if we assume each $X_{i}$ is a linear combination of $\{X_{j}\}_{j\in N(i)}$, then $\operatorname{Cap}(G)$ equals integral clique packing [9].

Theorem 11**.**

Let $G$ be a cycle with a number of chords such that endpoints of chords are at least distance 4 apart on the cycle. Then $\operatorname{Cap}(G)=n/2$.

Proof.

To show that $\operatorname{Cap}(G)\geq n/2$, consider the fractional matching where we place weight $1/2$ on every edge of the cycle. To show that $\operatorname{Cap}(G)\leq n/2$ we proceed as follows. Label the vertices that are endpoints of chords $c_{1},c_{2},\dots,c_{k}$ in the order they appear on the cycle. For every path between $c_{i}$ and $c_{i+1}$ (and between $c_{k}$ and $c_{1}$) pick the middle vertex of the path to be included in $X$. If the path is of odd length, pick either of the 2 middle vertices. We now show that $X$ and $Y=V\setminus X$ satisfy the conditions of Theorem 9. $X=S_{X}$ is an independent set. $G[Y]$ is a forest and $S_{Y}$ is an independent set due to the assumption on the distance between chord endpoints. ∎

6 Recovery from partial node failure

In this section, we extend the notion of storage capacity to cover for partial failures. This is a new generalization, that, as far as we understand, does not have a counterpart in index coding. As before, suppose we have a graph $G(V=[n],E)$ on $n$ vertices. We assume here that vertex $i\in[n]$ stores $X_{i}\in{\mathbb{F}}_{q}^{m}$, a $q$-ary random vector of length $m$. We want the following repair criterion to be satisfied: if up to any $\delta,0\leq\delta\leq 1,$ proportion of the $m$ coordinates of $X_{i},i\in[n]$ are erased, they can be recovered by using the remaining content of the vertex $i$ and $X_{N(i)}$, the contents in the neighbors of the vertex.

We call the normalized asymptotic maximum total amount of information (in terms of $q$-ary unit)

[TABLE]

that can be stored in the graph $G$, to be the partial recovery capacity of $G$. This is denoted by $\operatorname{Cap}_{q}(G,\delta)$.

We have the following simple facts. Recall, $\operatorname{Cap}^{(q)}(G)\equiv\sup_{m\in{\mathbb{Z}}_{+}}\operatorname{Cap}_{q^{m}}(G)$.

Proposition 12**.**

For a graph $G$, $\operatorname{Cap}_{q}(G,0)=n$ and $\operatorname{Cap}_{q}(G,1)=\operatorname{Cap}^{(q)}(G)$.

Proof.

The first statement is quite evident. For the second, note that,

[TABLE]

where we could use the $\lim$ and the $\sup$ interchangeably because of Fekete’s lemma, as discussed in the introduction. ∎

In the remaining parts of this section, we will provide tight upper and lower bound on the quantity $\operatorname{Cap}_{q}(G,\delta)$.

6.1 Impossibility bound

Note that, the partial recovery capacity can be defined in terms of an entropy maximization problem, generalizing the storage capacity.

Theorem 13**.**

Let $H(X)$ be the entropy of $X$ measured in $q$-ary units. Suppose, $X_{i}\in{\mathbb{F}}_{q}^{m}$, $i\in[n]$. For a graph $G([n],E)$, $\operatorname{Cap}_{q}(G,\delta)$ is upper bounded by the solution of the following optimization problem.

[TABLE]

such that,

[TABLE]

where $A_{q}(m,d)$ is the maximum possible size of a $q$-ary $m$-length error-correcting code with minimum distance $d$.

Proof.

Let $X_{i}\in{\mathbb{F}}_{q}^{m}$, $i\in[n]$ be the random variables that can be stored in the vertices of $G$ satisfying the repair condition. Suppose we are given the values of $X_{N(i)}$. In this situation let $M\subseteq{\mathbb{F}}_{q}^{m}$ be the set of possible values of $X_{i}$ ($P(X_{i}=a)>0,\forall a\in M$). Let $X_{i}^{1},X_{i}^{2}$ be any two different elements of $M$. We claim that, the Hamming distance between $X_{i}^{1},X_{i}^{2}$ is at least $\delta m+1$, or

[TABLE]

Suppose this is not true. Then there exist $X_{i}^{1},X_{i}^{2}\in M$ such that $d(X_{i}^{1},X_{i}^{2})\leq\delta m.$ Let $J\subset\{1,\dots,m\}$ be the coordinates where $X_{i}^{1}$ and $X_{i}^{2}$ differ. Therefore, $|J|\leq\delta m$. Suppose $X_{i}^{1}$ was stored in vertex $i$ and the coordinates in $J$ are erased. Now, there will not be any way to uniquely identify $X_{i}$: it can be either of $X_{i}^{1}$ or $X_{i}^{2}$. Hence the repair condition will not be satisfied which is a contradiction.

Therefore, $M\subseteq{\mathbb{F}}_{q}^{m}$ is a set of vectors such that any two elements of $M$ is Hamming distance at least $\delta m+1$ apart. Hence $M$ is an error-correcting code with minimum distance $\delta m+1$. And therefore, $|M|\leq A_{q}(m,d)$. This implies, $H(X_{i}\mid X_{N(i)})\leq\log_{q}A_{q}(m,\delta m+1),$ which proves the theorem. ∎

Let us define

[TABLE]

assuming the limit exists.

Corollary 14**.**

We must have, for any graph $G$, $\operatorname{Cap}_{q}(G,\delta)=\operatorname{Cap}^{(q)}(G)$ for $\delta\geq 1-\frac{1}{q}$. In particular, $\operatorname{Cap}_{2}(G,\delta)=\operatorname{Cap}^{(2)}(G)$ for $\delta\geq\frac{1}{2}.$

The proof of this fact follows since $R_{q}(\delta)=0$ for $\delta\geq 1-\frac{1}{q}$ (Plotkin bound, see [26, p. 127]).

Generalizing the technique of upper bounding the storage capacity via an information theoretic linear program, we can obtain an upper bound on $\operatorname{Cap}_{q}(G,\delta)$. We define a variable $z_{S}$ for every $S\subseteq V$ and let $\operatorname{bo}(S,T)=(\operatorname{cl}(S)\setminus S)\cap T$ denote the boundary of the set $S$ consisting of vertices in $T$ with all neighbors in $S$. Our main upper bound is the following.

Theorem 15**.**

Consider the LP below.

[TABLE]

The optimal solution to the above LP is an upper bound on $\operatorname{Cap}_{q}(G,\delta)$.

Proof.

The proof follows the same reasoning as the proof of the bound via information theoretic LP of Sec. 5.1. Indeed, the variable $z_{S}$ for every $S\subseteq V$ denote the entropy of $S$, $H(X_{S})$. The last constraint on the LP above follows from sub-modularity. To establish the second constraint, first note that $|T\setminus\operatorname{cl}(S)|=|T\setminus S|-|\operatorname{bo}(S,T)|$. Now we have to show that for any $S\subseteq T$,

[TABLE]

To see this, note that,

[TABLE]

where the last two lines follow from Thm. 13 and the definition of $R_{q}(\delta)$. ∎

Odd Cycle Example.

Consider an odd cycle with $n$ vertices where $n$ is odd. Below we show an example to illustrate the above bound on partial recovery capacity.

Consider the following subset of constraints:

[TABLE]

Equations (a) and (b) above are repeated applications of the inequality: $z_{S}+z_{T}\geq z_{S\cup T}+z_{\emptyset}$ if $S\cap T=\emptyset$. By summing up those constraints we get

[TABLE]

and thus

[TABLE]

whenever $G$ is an odd cycle.

6.2 Achievability bound

A naive achievability bound on $\operatorname{Cap}_{q}(G,\delta)$ is given by,

[TABLE]

where $h_{q}(x)\equiv x\log_{q}(q-1)-x\log_{q}x-(1-x)\log_{q}(1-x)$. This amount of storage can be achieved by just using an error-correcting code of length $m$, distance $\delta m+1$, and rate $1-h_{q}(\delta)$ in each of the vertices. Such codes exist, by the Gilbert-Varshamov bound. Also,

[TABLE]

for $0\leq\delta\leq 1-1/q$.

This simple bound can be improved by more carefully designing a code. Our main result of this section is the following.

Theorem 16**.**

Given a graph $G$, let ${\mathcal{C}}$ be the set of all cliques of $G$. The generalized clique packing number $\operatorname{CP}_{\delta}(G)$ is defined to be the optimum of the following linear program. For $0\leq x_{C}\leq 1,\forall C\in{\mathcal{C}}$,

[TABLE]

such that,

[TABLE]

Then,

[TABLE]

and,

[TABLE]

Proof.

First of all, notice that, $\operatorname{Cap}_{q}(G,\delta)\geq\operatorname{Cap}_{q}(G,1)=\operatorname{Cap}^{(q)}(G)\geq\operatorname{CP}(G)$ where the last inequality follow from Lemma 1. Below therefore we only concentrate on the case when $\delta\leq 1-\frac{1}{q}.$ We illustrate the proof of this theorem by constructing a sequence of error-correcting codes that serves our purpose.

First, we show that for any positive integer $d$ and a large enough positive integer $m$, there exists a linear error-correcting code of length $dm$ and dimension $dm-mh_{q}(\delta)$ that can correct any $\delta m$ erasures between coordinates $im+1$ and $(i+1)m$ for any $i\in\{0,1,\dots,d-1\}$.

Randomly and uniformly choose a $q$-ary parity check matrix of size $(dm-k)\times dm$ (that is, each coordinate of the matrix is chosen from $\{0,1,\dots,q-1\}$ with uniform probability). The probability that a vector of weight $\delta m$ is a codeword is $q^{-(dm-k)}$. Now the probability that there exists such a codeword that is an uncorrectable erasure pattern of the above type is

[TABLE]

Hence there exists such a code with dimension $dm-mh_{q}(\delta)$ for any $\delta\leq 1-\frac{1}{q}$ for large enough $m$.

Suppose, $C\in{\mathcal{C}}$ be a clique of size $d=|C|$ in $G$. Use the linear error-correcting code of length $dm$ constructed above and store each block of $m$ coordinates in one of the vertices of the clique. If up to $\delta$ proportion of the content of any vertex is erased, it can be recovered by accessing the other vertices. The total information stored in this clique is $dm-mh_{q}(\delta)=m(|C|-h_{q}(\delta))$.

Now let us find a partition of the graph into a collection of cliques $\{C_{1},C_{2},\dots,C_{t}\}$, such that each vertex belongs to at most one clique from the collection. For each clique $C_{i},i=1,\dots,t,$, use an error-correcting code of length $|C_{i}|\cdot m$ to store $m(|C_{i}|-h_{q}(\delta))$ $q$-ary information. In this way the maximum amount of information that can be stored in the graph with the partial recovery condition is,

[TABLE]

where $x_{C}\in\{0,1\}$ denotes whether the clique $C$ is in the collection, under the constraint that each vertex is in only one clique, i.e., $\sum_{C\in{\mathcal{C}}:u\in C}x_{C}\leq 1.$ This is an integer linear program and $\operatorname{Cap}_{q}(G,\delta)$ is at least the optimum value of this integer linear program for $\delta\leq 1-\frac{1}{q}.$

Now, following an argument similar to Lemma 1, we show that the integer linear program can be relaxed to a linear program and an achievability scheme still exists. For this, assume, $\{x_{C}\}_{C\in{\mathcal{C}}}$ achieve $\operatorname{CP}_{\delta}(G)$. Let $m$ be such that ${x_{C}}\cdot m$ is integral and large enough for every $C$. For each clique $C=\{u_{1},\ldots,u_{|C|}\}$ in the graph, in each vertex $u\in C$, store $mx_{C}$ $q$-ary symbols, such that the $|C|\cdot mx_{C}$-length vector in the clique $C$ is a codeword of an error correcting code of length $|C|\cdot mx_{C}$ that can carry $mx_{C}(|C|-h_{q}(\delta))$ symbols of information, as noted above. Once we do this for all cliques, the number of $q$-ary symbols stored in vertex $u$ is $\sum_{C\in{\mathcal{C}}:u\in C}x_{C}m\leq m.$ The total amount of information stored in the graph is $\sum_{C\in{\mathcal{C}}}mx_{C}(|C|-h_{q}(\delta))=m\operatorname{CP}_{\delta}(G)$.

This proves the claim. ∎

Odd Cycle Example.

Let us consider the example of $n$-cycle again where $n$ is an odd number. Since the size of a fractional matching is $\frac{n}{2}$, we have

[TABLE]

and $\operatorname{Cap}_{q}(G,\delta)\geq\frac{n}{2}$ when $\delta>1-\frac{1}{q}$. Compare this with the impossibility bound that we have,

[TABLE]

It is widely conjectured that the optimal rate of an error-correcting code is given by

[TABLE]

for small $q$, which is also known as the Gilbert-Varshamov conjecture. If this conjecture is true, then our upper and lower bounds match exactly. In particular, for large $q$ (i.e., $q\to\infty$), we have $h_{q}(\delta)\to\delta$ and $R_{q}(\delta)\to 1-\delta.$ Hence, our bounds match definitively in the regime of large $q$.

7 Conclusions

Storage capacity is a natural problem of network coding and intimately related to the index coding problem which encapsulates the computational challenges of general network coding. In this paper we have viewed storage capacity as a natural information theoretic analog of vertex cover of graph. For some family of graphs, vertex cover is easier to approximate, such as the planar graphs; we see that, the storage capacity is also easier to estimate for these families. The relation to index coding also leads to approximation guarantees for index coding rate. We further illustrated an approach to bound the storage capacity of graphs in terms of a small number of vertex covers, which leads us to exactly quantify the storage capacity of cycles with chords.

In the last part of this paper, we provided one possible generalization of the storage capacity to partial recovery capacity. It is important to note that there are several other possible generalizations to this quantity that may be useful in practice. For example, one might consider recovery from failure of multiple vertices together from their combined neighborhood (analogous to the cooperative repair problem in distributed storage [25]). In yet another scenario of recovery from multiple failures, a vertex failure may be recoverable from its neighborhood as long as at most $t\geq 0$ of its neighbors have also failed. We leave these generalizations as interesting future studies of storage capacity.