Coded Caching with Linear Subpacketization is Possible using Ruzsa-Szem\'eredi Graphs

TL;DR

This paper introduces a new coded caching scheme with linear subpacketization, utilizing Ruzsa-Szeméredi graphs, enabling efficient data delivery with polynomially many transmissions, addressing a key open problem.

Contribution

It presents the first coded caching scheme with linear subpacketization using Ruzsa-Szeméredi graphs, achieving near-constant transmission rates with polynomial complexity.

Findings

Achieves coded caching with linear subpacketization.

Uses Ruzsa-Szeméredi graphs as a novel technical tool.

Supports polynomial number of transmissions in the number of users.

Abstract

Coded caching is a problem where encoded broadcasts are used to satisfy users requesting popular files and having caching capabilities. Recent work by Maddah-Ali and Niesen showed that it is possible to satisfy a scaling number of users with only a constant number of broadcast transmissions by exploiting coding and caching. Unfortunately, all previous schemes required the splitting of files into an exponential number of packets before the significant coding gains of caching appeared. The question of what can be achieved with polynomial subpacketization (in the number of users) has been a central open problem in this area. We resolve this problem and present the first coded caching scheme with polynomial (in fact, linear) subpacketization. We obtain a number of transmissions that is not constant, but can be any polynomial in the number of users with an exponent arbitrarily close to zero. Our central technical tool is a novel connection between Ruzsa-Szem\'eredi graphs and coded caching.

Equations

$$r=\frac{1}{t}\sum _{i=1}^t|M_i|=\frac{1}{t}|E|,$$

$$(1-\frac{M}{N})K.$$

$$\left(p_1,p_2\right),\left(p_3,p_4\right)\dots \left(p_{2r_i-1,2r_i}\right).$$

$$\{(p_{2k-1},d_{p_{2k}}),(p_{2k},d_{p_{2k-1}}){\}}_{1\le k\le r_i}.$$

$$(K-d_i)N\le \frac{M}{N}KN=MK=MF.$$

$$\left(p_1,p_2\right),\left(p_3,p_4\right)\dots \left(p_{2r_i-1,2r_i}\right),$$

$$\{(p_{2k-1},d_{p_{2k}}),(p_{2k},d_{p_{2k-1}}){\}}_{1\le k\le r_i}.$$

$$g=2-\frac{1}{2C^4\ln C}+o(1),$$

$$f=1+2\frac{\ln 10.5}{\ln C}+o(1).$$

$$|\{y\in V:(x,y)\in E\}|\ge K\left(1-2K^{-\frac{1}{2C^4\ln C}}\right).$$

$$|\{y\in V:(x,y)\notin E\}|$$

$$\le 2K\exp \left(-\frac{n}{2C^4}\right)=2K^{1-\frac{1}{2C^4\ln C}}.$$

Full text

1 Introduction

The number and display capabilities of devices connected to the Internet through cellular wireless is rapidly increasing. This is leading to a dramatic increase in wireless traffic, predominantly driven by video content demand [18, 14]. System designers fortify 5G wireless networks with infrastructure densification and increased rates, as much as possible, but backhaul links become congested as the number of base stations and rates increase [3]. The idea of Femtocaching [7, 18] was to add storage to small-cell base stations so that they can cache popular content and hence relieve the backhaul links. These links can even be wireless and pre-populate caches during low-traffic times, effectively converting the wireless infrastructure to a content delivery network (CDN) at the edge. Caching for wireless networks has been recognized as a disruptive technology for 5th generation (5G) cellular networks [5, 21].

Caching helps in two fundamentally different ways. The first is the obvious one: If we cache popular content at a nearby small-cell a user can find it with local communication and cause less interference and no overheads to the macro-cell. Resource allocation for this problem is still highly non-trivial: Even for a known, fixed popularity distribution, deciding what to cache where is an NP-hard combinatorial optimization problem. Interestingly this problem can be provably approximated using submodular function optimization [18]. There are several other challenging aspects that must be addressed like including device-to-device communication [6], learning popularity distributions [4] and mobility [15], among others. Resource allocation for caching in wireless networks is currently a rich area of active research.

Caching also helps in a second, surprising way: even when the cached content is not desired nearby it may be desired far away. This may create broadcast coding opportunities where a macro-cell transmits the XOR of two files and each user uses their cache to cancel the non-desired file. This caching benefit is unique to wireless channels and is an example of index coding [2], a fundamental problem in information theory. The study of optimal design of caches to exploit this benefit due to coding was initiated by Maddah-Ali and Niesen in their pioneering work [11, 12], often called the coded caching problem.

In the Coded caching problem [11], there is a library of $N$ files and $K$ users. Each user requests one of the files and has a local cache that can fit the equivalent of $M$ files. The problem is to design what each user caches from the library, before seeing what each user requests: The placement phase has to be designed such that, in the subsequent delivery phase, any set of user demands from the library can be satisfied using at most $R$ transmissions. In other words, all the users may decide to request the second file, or different files (out of the $N$ possible) and a base station has to decide what to transmit. Each user’s cache now acts as pre-designed side information which can be used to broadcast linear combinations of packets. Coded caching can be seen as index coding with a twist: the side information sets can be designed, but the user requests are selected subsequently, in an adversarial fashion.

Since there are $K$ users, each requesting one file, the base station can trivially satisfy everyone using $R=K$ transmissions, even without any use of caching. Furthermore, every user can cache $\frac{M}{N}$ of every file. The base station can then transmit the remaining $1-\frac{M}{N}$ of each file, requiring in total $R=K(1-\frac{M}{N})$ transmissions. This is just a conventional use of caching; slightly better than the trivial $R=K$ but not significantly, since it also scales linearly111Throughout this paper we assume (when we informally write about scaling laws) that $M/N$ is a constant, and $K$ scales to a large number of users. Despite this, our mathematical claims hold more generally, for any scaling relation between $M,N,K$ and we include all the parameters explicitly in our theorems. in the number of users $K$.

The surprising result of Maddah-Ali and Niesen [11] is that using coded caching it is possible to satisfy any request pattern using only $R=\frac{N}{M}$ transmissions, i.e. a constant number of transmissions, not scaling in the number of users $K$. A number of subsequent works [9, 8, 13, 10] have introduced order optimal schemes for variations of the problem and established similar strong performance bounds.

The central limitation of all previous works is the problem of exponential subpacketization: Coded caching requires every file to be separated into $F$ subpackets that are then stored in user caches. In the original scheme [11], the number of packets $F$ was scaling exponentially in the number of users $K$ (for constant $M/N$). Maddah-Ali and Niesen [12] also showed that even if the placement is random, i.e. every user caches a random $\frac{M}{N}$ fraction of every file, then the same rate $R\approx\frac{N}{M}$ under adversarial user demands is possible. These schemes are called decentralized caching schemes since very little coordination is required among the user caches. This analysis required that $F\rightarrow\infty$. Subsequently, [19] showed that for any $F\leq\exp(K\,M/N)$, a linear number of transmissions $R\geq cK$ would be required for some constant $c$. Therefore, the benefits of coded caching appear only when $F$ scales exponentially in the number of users $K$, making these schemes non-practical.

The problem of subpacketization is a central one in caching, since it was realized in [19]. Very recent work [20, 22, 17, 23] has investigated better achievability schemes with a smaller number of packets, for the centralized case: Tang and Ramamoorthy [20] connected coded caching to resolvable combinatorial designs and showed a scheme where $R\approx\frac{N}{M}$ while improving exponentially over the previous scheme by [11], but still requiring exponential subpacketization. A similar result was shown in [22] through a very interesting construction called a “Placement Delivery Array” (PDA). Shangguan et al. [17] connected this problem to the construction of some hypergraphs with extremal properties and showed the first sub-exponential (but still intractable) scheme: $F=\exp\left(\sqrt{K}\right)$. Furthermore, they established that such hypergraphs do not exist when $F=O(K)$ for a constant number of transmissions $R$. Yan et al. [23] connected the PDA formulation to another graph problem and derived a centralized caching scheme with optimal non-scaling $R$, but $F$ scales super-polynomially in the number of users $K$.

Our Contribution: We present the first coded caching scheme with polynomial (in fact, linear) subpacketization. For any arbitrarily small constant $\delta$, we show that there is a small $\epsilon=\epsilon(\delta)>0$ such that we can design a centralized coded caching scheme that satisfies $K$ users with $R=K^{\delta}$ transmissions using only $F=K$ packets. This is possible for any constant ratio $\frac{M}{N}$, in fact it suffices if $\frac{M}{N}\geq K^{-\epsilon}$.

Our central technical tool is a novel connection between Ruzsa-Szeméredi graphs [16, 1] and coded caching. We show that any $(r,t)$ Ruzsa-Szeméredi graph on $K$ vertices and $\Theta(K^{2})$ edges corresponds to a centralized coded caching scheme with $F=K$ and constant (or $o(1)$) $M/N$. Leveraging this, we show that an existing Ruzsa-Szeméredi construction from [1] gives an explicit coded caching scheme with $R=K^{\delta}$, $\frac{M}{N}\geq K^{-\epsilon}$ and $F=K$ for any small $0<\delta<1$, large enough $K$ and with $\epsilon=c_{1}\delta\exp(-\frac{c_{2}}{\delta})$ for some positive constants $c_{1}$ and $c_{2}$. Note that our results do not violate the impossibility results established in [17] since they apply for linear file sizes and constant $R,\,M/N$.

We emphasize that the graph constructions we use [1] require very large $K$ and do not seem directly applicable for real caching systems. In any case, we find it quite surprising that linear packet sizes $F=K$ are possible for near-optimal number of transmissions. We believe this path can lead to practical coded caching schemes.

2 Ruzsa-Szeméredi Graphs and Coded Caching

We start with the definition of Ruzsa-Szeméredi Graphs and establish the connection to the centralized coded caching problem. Some graph theoretic notions are reviewed before that: Let $G(V,E)$ be an undirected graph on the set of vertices $V$ and edge set $E$. $G_{S}$ denotes the induced subgraph on the vertex set $S\subseteq V$. A matching $M\subseteq E$ is a subset of edges which are pairwise disjoint (no two edges have a common vertex).

Definition 1**.**

The set of edges $M\subseteq E$ is an induced matching if for the set $S$ of all the vertices incident on the edges in $M$, the induced graph $G_{S}$ contains no other edges apart from those in the matching $M$.

Definition 2**.**

An $(r,t)$- Ruzsa-Szeméredi graph is a graph on $n$ vertices such that the edge set $E$ can be partitioned into $t$ pairwise edge-disjoint induced-matchings of average size $r$.

Remark: Note that the usual definition of Ruzsa-Szeméredi graph is when all the induced matchings have the exact same size $r$. Here, we adopt a weaker definition as it suffices to draw a connection to the coded caching problem.

To review the coded caching problem: there is a noiseless broadcast channel between a server that has access to a library of $N$ files and $K$ users each of whom is equipped with a local cache of size $M$. The problem is to design the placement phase where the user cache is filled by file packets from the library subject to the cache constraint and the delivery phase where any demand pattern of the $K$ users arising from the library is satisfied with at most $R$ file transmissions.

Let $\mathbf{x}_{i}\in\mathbb{F}^{F\times 1}$ denote a vector of length $F$ over the field $\mathbb{F}$ presenting the $i$-th file in the library. Based on this, we define a $(R,K,M,N,F)$ coded caching scheme as follows:

Definition 3**.**

Let every file in the library contain $F$ packets. An (R,K,M,N,F) coded caching scheme consists of:

A family of subsets $\{S_{p,f}\}_{p\in[1:N],f\in[1:K]}$ where $S_{p,f}\subseteq[1:K]$ is the set of user caches where the packet $p$ of file $f$ is stored. The placement is such that every user cache contains at most $MF$ file packets. 2. 2.

For any set of user demands arising from the library of $N$ files, i.e. $\{d_{1},d_{2}\ldots d_{K}\}\in[1:N]^{K}$, we define the transmission function $\phi\left(\mathbf{x}_{d_{1}},\ldots\mathbf{x}_{d_{K}}\right)\rightarrow\mathbb{F}^{RF\times 1}$ for some field $\mathbb{F}$ such that every user can decode their demanded packets $\mathbf{x}_{d_{k}}$ using $\phi(\cdot)$ and the cache content available. 3. 3.

The number of file transmissions is at most $R$ for any demand pattern among the users arising from the library.

Remark: For some specific demand patterns, $RF$ transmissions may not be needed. However, we zero pad the transmissions to get $RF$ packets over $\mathbb{F}$ for notational convenience.

We can now establish the connection between Rusza-Szeméredi Graphs and Coded Caching Schemes. This is inspired by the Placement Delivery Array formulation of coded caching from [22, 17, 23]. Although there is a connection between square symmetric PDA and a Rusza-Szemeredi graph with appropriate parameters, we will state the connection to coded caching and prove it in a more direct fashion.

We call the following coded caching scheme a Ruzsa-Szeméredi scheme for any $(r,t)$- Ruzsa-Szemeredi graph on $K$ vertices.

Definition 4**.**

(Ruzsa-Szeméredi Coded Caching Scheme) Let $G(V,E)$ be an $(r,t)$ Ruzsa-Szeméredi graph on $K$ vertices with $t$ pairwise edge disjoint induced matchings $M_{1},M_{2}\ldots M_{t}$ with average size

[TABLE]

and minimum degree at least

[TABLE]

We now describe a placement and a feasible delivery scheme guided by the structure of the graph called the $(K,t,r,\frac{M}{N})$ Ruzsa-Szeméredi Scheme.

Let us consider an edge $\{i,j\}\notin E$. Every file in the coded caching scheme is split into $F=K$ packets. Then, we store the $i$-th packet of all files in the library in the cache of user $j$ and we store the $j$-th packet of all files in the library in the cache of user $i$. 2. 2.

The delivery is based on the induced matchings in $G$. The edge-set of $G$ partitions into $t$ induced matchings of average size $r$. For any $1\leq i\leq t$, consider the matching $M_{i}$ of size $r_{i}$. Let the matching consist of the $r_{i}$ edges

[TABLE]

We XOR the $2r_{i}$ packets:

[TABLE]

The delivery scheme consists of $t$ packet transmissions and hence $t/F$ file transmissions.

We present an illustration of the coded caching scheme in the above definition through an example in Figure 1. Figure 1 is based on a simple $(2,3)$ Ruzsa-Szeméredi graph on $6$ vertices. Every non-edge represents a storage action in the placement phase. Every induced matching corresponds to an XOR in the delivery phase.

Theorem 1**.**

Any $(K,t,r,\frac{M}{N})$ Rusza-Szemeredi Scheme is an $(R=\frac{t}{K},K,M,N,F=K)$ coded caching scheme.

Proof.

The number of users $K$ is equal to the number of packets per file $F$ in the construction, i.e. $K=F$. We first check if the memory constraint is satisfied. For a specific user $j$, the number of packets per file stored at the user is $K-d_{j}$ where $d_{j}$ is the degree of vertex $j$. Therefore, the total number of file packets stored is

[TABLE]

Therefore, the cache memory constraint of every user is satisfied. Further, the number of file transmissions ($R$) is seen to be $t/F$.

We now show that the scheme above satisfies any set of user demands. Consider the matching $M_{i}$ consisting of edges $r_{i}$ edges

[TABLE]

and the XOR transmission corresponding to this matching consisting of $2r_{i}$ packets:

[TABLE]

First, we show that, from the XOR consisting of the packets mentioned above, every user in $\{p_{1},p_{2}\ldots p_{2r_{i}}\}$ recovers at least one packet used in the XOR that they desired. This decoding is done at every user by just using this XOR and the cache content. It is enough to show that every user $k\in\{p_{1},p_{2}\ldots p_{2r_{i}}\}$, has all but $1$ packet from the $2r_{i}$ packets used in the XOR in its cache. We consider the following two cases:

User $p_{q}:q\in\{1,2\ldots 2r_{i}\}$, $q$ is odd: Then, the user desires the packet $(p_{q+1},d_{p_{q}})$ from the XOR formed from the matching $M_{i}$. Suppose, user $p_{q}$ does not possess packet $p_{m}$ of some file for $m\neq q+1,~{}m\in\{1,\ldots 2r_{i}\}$. Then, it means that $\{p_{m},p_{q}\}$ is an edge in $E$ as according to the placement described, as only non edges correspond to placement actions. This is impossible since vertices $p_{m},p_{q}$ belong to the induced matching $M_{i}$ and there is no edge between $p_{m}$ and $p_{q}$ for $m\neq q+1$ (Note that there is no self-loop in the graph). Hence, user $p_{q}$ possesses packet $p_{m}$ belonging to all files where $m\neq q+1,~{}m\in\{1,2\ldots 2r_{i}\}$. 2. 2.

User $p_{q}:q\in\{1,2\ldots 2r_{i}\}$, $q$ is even. A similar argument holds but we will give the details for the sake of completeness. The user desires the packet $(p_{q-1},d_{p_{q}})$ from the XOR formed from matching $M_{i}$. Suppose, user $p_{q}$ does not possess packet $p_{m}$ of some file for $m\neq q-1,~{}m\in\{1,\ldots 2r_{i}\}$. Then, it means that $\{p_{m},p_{q}\}$ is an edge in $E$ as according to the placement described, as only non edges correspond to placement actions. This is impossible since vertices $p_{m},p_{q}$ belong to the induced matching $M_{i}$ and there is no edge between $p_{m}$ and $p_{q}$ for $m\neq q-1$. Hence, user $p_{q}$ possesses packet $p_{m}$ belonging to all files where $m\neq q-1,~{}m\in\{1,2\ldots 2r_{i}\}$.

Now, we argue that all demanded packets are delivered to their respective users using the matching based delivery scheme. Consider a packet $(f,d_{k}),~{}1\leq f\leq K=F,~{}1\leq k\leq K$ demanded by user $k$. Suppose this packet was not cached by user $k$, then $(f,k)$ is an edge in the graph and because the edge set partitions into induced matchings, it belongs to some induced matching $M_{q}$, $1\leq q\leq t$. Therefore, the $q$-th XOR in the above delivery scheme would enable user $k$ to decode the packet $(f,d_{k})$. This completes the proof.

∎

In what follows, we consider a known construction of a dense $(r,t)$-Ruzsa-Szeméredi graph that decomposes into almost near linear number of induced matchings and indicate how it gives rise to coded caching schemes when the file size is linear in the number of users using the connection described above.

2.1 The Ruzsa-Szeméredi Construction by Alon, Moitra and Sudakov

In this section, we describe a coded caching scheme with almost constant number of transmissions ($R$ is almost a constant) and file size $F$ required is linear in $K$ even for a sub-constant user cache to library size ratio ($\frac{M}{N}$) We describe a Ruzsa-Szeméredi graph from [1].

Definition 5**.**

Define a graph $G(V,E)$ as follows: $V=[C]^{n}$ where $C$ is a positive integer. $|V|=K=C^{n}$. $n$ is even, $n\geq 2C$. Suppose $x$ and $y$ are sampled uniformly from $V$, let $\mu=\mathbb{E}_{x,y}\left[\lVert x-y\rVert_{2}^{2}\right]$. Consider a pair of ordered tuples $u,v\in[C]^{n}$. Now, $(u,v)\in E$ if and only if $\lVert\lVert u-v\rVert_{2}^{2}-\mu\rVert<n$.

Theorem 2**.**

[1]** The graph $G$ defined in Definition 5 is an $(r,t)$-Ruzsa-Szeméredi graph on $K=C^{n}$ vertices where the edge set partitions into $t=K^{f}$ edge disjoint induced matchings and it has at most $K^{g}$ edges missing such that

[TABLE]

and

[TABLE]

We make the following simple observation to make it easier to connect it to the coded caching scheme.

Lemma 1**.**

Consider any vertex $x\in V=[C]^{n}$ in $G$ as in Definition 5. Let $K=C^{n}$. The degree of $x$ is:

[TABLE]

Proof.

The proof is identical to Claim $2.1$ in [1] except that this is for neighbors of a single vertex. Consider $y$ sampled uniformly randomly from $V$. Then $(x_{i}-y_{i})^{2}$ is a bounded random variable with support $[0,C^{2}]$ and i.i.d with respect to the index $i$. Therefore applying Hoeffding’s inequality, we have:

[TABLE]

The degree of vertex $x$ is $K-\lvert\{y\in V:(x,y)\notin E\}\rvert$. Therefore, (2.1) implies the result. ∎

Theorem 3**.**

With the construction of [1] given in Definition 5, the corresponding Ruzsa-Szeméredi scheme according to Definition 4 yields a $(R=K^{2\frac{\mathrm{ln}10.5}{\mathrm{ln}C}+o(1)},K,M,N,F=K)$ coded caching scheme whenever $\frac{M}{N}\geq 2K^{-\frac{1}{2C^{4}\mathrm{ln}C}}$ where $K=C^{n}$, $n$ even and $n\geq 2C$.

Proof.

Theorem 2 shows that the Ruzsa-Szeméredi graph construction in Definition 5 has the following properties:

It is on $K$ vertices such that $K=C^{n},n\geq 2C$ 2. 2.

Number of edge disjoint induced matchings is $t=K^{1+2\frac{\mathrm{ln}10.5}{\mathrm{ln}C}+o(1)}$ 3. 3.

Average size of each matching is at least $r=K^{2}\left(1-K^{-\frac{1}{2C^{4}\mathrm{ln}C}+o(1)}\right)/t$.

Further, Lemma 1 guarantees that the minimum degree of this construction is at least $K(1-2K^{-\frac{1}{2C^{4}\mathrm{ln}C}})$. By Definition 4, this yields a $\left(K,t=K^{1+2\frac{\mathrm{ln}10.5}{\mathrm{ln}C}+o(1)},r=K^{2}\left(1-K^{-\frac{1}{2C^{4}\mathrm{ln}C}+o(1)}\right)/t,\frac{M}{N}\right)$ Ruzsa-Szeméredi scheme whenever $\frac{M}{N}\geq 2K^{-\frac{1}{2C^{4}\mathrm{ln}C}}$ . By Theorem 1, this implies a feasible coded caching scheme with parameters stated in the theorem. This completes the proof. ∎

We restate the result in a different way in the following corollary:

Corollary 1**.**

For any $0<\delta<1$, the construction of [1] given in Definition 5 gives a $(R=K^{\delta},K,M,N,F=K)$ coded caching scheme for $K\geq K\left(\delta\right)$ (large enough $K$) with $\frac{M}{N}\geq 2K^{-c_{1}\delta\exp\left(-\frac{c_{2}}{\delta}\right)}$ where $c_{1},c^{\prime}_{2}$ are universal positive constants.

Proof.

We set $\delta=2\frac{\mathrm{ln}10.5}{\mathrm{ln}C}$. Then, $\frac{1}{2C^{4}\mathrm{ln}C}=c_{1}\delta\exp\left(-\frac{c_{2}}{\delta}\right)$ for some universal positive constants $c_{1},c_{2}$. For large enough $C$, $\delta$ can be made to lie in $(0,1)$ and correspondingly $K$ increases as function of $\delta$ since $K=C^{n}$ by construction. Substituting the re-parameterized values proves the result. ∎

Remark: This shows that, for sub-constant $\frac{M}{N}$ and large enough $K$, there are coded caching schemes with file size $F$ linear in $K$ with almost constant number of transmissions.

3 Conclusion

We presented a connection between Ruzsa-Szeméredi Graphs studied in extremal combinatorics and the coded caching problem. We showed that a dense Ruzsa-Szeméredi construction gives coded caching schemes with file size linear in the number of users. We leveraged an existing graph construction to show that coded caching schemes with file size linear in the number of users, sub-constant user cache to library size ratio and almost constant transmission rate for any set of demands is possible when the number of users is large. This settles an outstanding question of existence of schemes with linear file size and very small rate in this line of work. The construction used in this work requires the number of users $K$ to be very large which may be impractical. It would be of great interest to construct Ruzsa-Szeméredi graphs (more general bipartite versions) in the dense regime where the number of vertices is not very large.