On the Fundamental Limits of Coded Caching with Correlated Files
Kai Wan,Â
Daniela Tuninetti,Â
Mingyue Ji,Â
and Giuseppe Caire
A short version of this paper was presented at the 2019 IEEE International Symposium on Information Theory.
K. Wan and G. Caire are with the Electrical Engineering and Computer
Science Department, Technische Universität Berlin, 10587 Berlin, Germany
(e-mail: [email protected]; [email protected]). The work of K. Wan and G. Caire was partially funded by the European Research Council under the ERC Advanced Grant N. 789190, CARENET.
D. Tuninetti is with the Electrical and Computer Engineering Department, University of Illinois at Chicago, Chicago, IL 60607, USA (e-mail: [email protected]). The work of D. Tuninetti was supported in part by NSF Award 1527059.
M. Ji is with the Electrical and Computer Engineering Department, University of Utah, Salt Lake City, UT 84112, USA (e-mail: [email protected]). The work of M. Ji was supported in part by NSF Awards 1817154 and 1824558.
Abstract
This paper studies the fundamental limits of the shared-link coded caching problem with correlated files, where a server with a library of N files communicates with K users who can locally cache M files.
Given an integer râ[N], correlation is modeled as follows: each r-subset of files contains a unique common block. The tradeoff between the cache size and the average transmitted load is considered.
First, a converse bound under the constraint of uncoded cache placement (i.e., each user directly stores a subset of the library bits) is derived.
Then, a caching scheme for the case where every user demands a distinct file (possible for NâĽK) is shown to be optimal under the constraint of uncoded cache placement.
This caching scheme is further proved to be decodable and optimal under the constraint of uncoded cache placement when (i) KrMâ¤2N or KrMâĽ(Kâ1)N or râ{1,2,Nâ1,N} for every demand type (i.e., when the demanded file are not necessarily distinct), and (ii) when the number of distinct demanded files is no larger than four.
Finally, a two-phase delivery scheme based on interference alignment is shown to be optimal to within a factor of 2 under the constraint of uncoded cache placement for every possible demands.
As a by-product, the proposed interference alignment scheme is shown to reduce the (worst-case or average) load of state-of-the-art schemes for the coded caching problem where the users can request multiple files.
I Introduction
Cache is a network component that leverages the device memory to transparently store data so that future requests for that data can be served faster. Two phases are included in a caching system: i) cache placement phase: content is pushed into each cache without knowledge of future demands; ii) delivery phase: after each user has made its request and according to the cache contents, the server transmits coded packets in order to satisfy the user demands. The goal is to minimize the number of transmitted bits (or load or rate).
Information theoretic coded caching was originally proposed by Maddah-Ali and Niesen (MAN) in [1] for a shared-link caching systems containing a server with a library of N equal-length files, which is connected to K users through a noiseless shared-link, each of which can store M files in their local cache. Each user demands one file in the delivery phase. The MAN scheme uses a combinatorial design in the placement phase such that during delivery multicast messages simultaneously satisfy the demands of different users.
Under the constraint of uncoded cache placement (i.e., each user directly caches a subset of the library bits) and for worst-case load, the MAN scheme was proved to be optimal when NâĽK [2].
On the observation that some MAN linear combinations are redundant if there exist files demanded by several users, the authors in [3] improved the MAN delivery scheme and achieved the optimal worst-case load under the constraint of uncoded cache placement for any K. The same authors proved in [4] that the multiplicative gap between the optimal caching scheme with uncoded cache placement and any caching scheme with coded cache placement is at most 2.
Coded caching strategy was also extended to numerous different models, such as decentralized systems [5], device-to-device (D2D) systems [6], topological networks [7, 8, 9], etc.
The above works aassume that all the files in the library are independent. However, in practice there may be some overlaps among different files (e.g., videos, image streams, etc.).
In this work, we consider such a coded caching problem with correlated sources, as originally proposed in [10], where different files have common parts.
In the following, we will review the literature of coded caching with correlated sources, and introduce our main contributions in this paper.
I-A Past Work
Coded Caching with Correlated Sources
In¸itehas2016correctedsource, the authors modeled correlation as each subset of files has an exclusively common part, which is independent to the common parts of other subsets of files.
By treating the delivery phase as an index coding problem with multiple requests, the authors in [10] proposed a delivery scheme based on graph coloring. In [11] a caching scheme for two-file Kâuser system and three-file two-user systems based on Gray-Wyner source coding.
In [12], the caching problem with correlated files, where the length of the common part among each ââ{1,âŚ,N} files (referred to as a ââ-blockâ) is the same, was considered; each file contains (ââ1Nâ1â) ââblocks.
By using the MAN cache placement to store each â-block at the user sides, [12] proposed a delivery phase which contains N steps. In step â only â-blocks are transmitted; thus there are (ââ1Nâ1â) rounds for the transmission of Step â. Each round is treated as an MAN caching problem with K users, each of which should decode exactly one â-block. The authors then used the caching scheme in [3] to transmit packets for each round.
The caching schemes in [11] and [12], were extended in [13] and [14] to caching problems with
correlated files where the correlation is dynamic and the channel is a Gaussian broadcast channel, respectively.
Coded Caching with Multiple Requests
The caching problem with correlated files in [12] is a special case of coded caching with multiple requests considered in [15], where the library contains N equal-length and independent files and each user demands L files from the library.
With the MAN placement, to divide the delivery phase into L rounds where in each round the MAN scheme in [1] is used to let each user decode one file, can achieve a generally order optimal worst-case load to within a factor of 18 [15]. By further tightening the converse bound, this order optimality factor was reduced to 11 in [16].
Instead of using the MAN scheme in each round, the authors in [17] proposed to use the caching scheme in [3] to leverage the multicast opportunities.
In addition, by considering all the L rounds, an overall transmission coding matrix can be generated. If the coding matrix is not full-rank, they then take the full-rank sub-matrix. This delivery scheme was proved to be optimal under the constraint of the MAN placement for demands with Kâ¤4, M=N/K, and L=2, with the exception of one demand for K=3 and three demands for K=4.
Coded caching with multiple requests, where each user demands different number of files, was considered in [18, 19, 20, 21]. The caching schemes in [18, 19, 20] are based on the round-division strategy as described above while the one in [21] considered small memory size regime and used Minimum Distance Separable (MDS) coded cache placement.
Most of the existing works divide the multi-request problem into a sequence of single-request problems (as in [12, 15, 16, 17]).
There are three main limitations in dividing the delivery into single-request problems, namley
(1) the same file may exist in different rounds and this round-division method may miss some multicast opportunities,
(2) even if there does not exist file overlap cross different rounds, this round-division method still cannot fully leverage the multicast opportunities (as illustrated in Example V-A), and
(3) finding the best division of the usersâ demands into L groups is computationally hard.
I-B Contributions
If one directly considers the most general problem of correlated files, it is very challenging to make general optimality statements. In this paper, we consider a symmetric version of the problem, for which we propose a novel interference alignment based delivery scheme, which jointly serves usersâ demands instead of dividing the delivery into single-request problems.
The considered model is the following simplification of the model in [12]: we fix râ[N] and assume each file only contains r-blocks (see Section II).
Our main contributions are as follows:
-
We derive a converse bound on the minimal average load among all possible demands under the constraint of uncoded cache placement. We leverage the acyclic index coding converse bound as in [22, 23].
2. 2.
By jointly serving the usersâ demands, we propose a caching scheme for the case where every user demands a distinct file and whose load matches our proposed converse bound under the constraint of uncoded cache placement.
3. 3.
By combining the above achievable scheme with an interference alignment idea, we then propose a two-phase delivery scheme for general demands, where the first sub-phase is the same as the one for distinct demand case and the additional second sub-phase is used to align interference at the various users. The two-phase interference alignment delivery scheme is proved to be order optimal within a factor of 2 for any demand type.
4. 4.
By further cancelling interference, we prove that the second sub-phase in the above two-phase delivery is not necessary, thus resulting in exact optimality under the constraint of uncoded cache placement, for
(i) for any demand type if either KrMâ¤2N or KrMâĽ(Kâ1)N or râ{1,2,Nâ1,N}, and (ii) when the number of distinct demanded files is no larger than four.
5. 5.
As a by-product, a modification of our proposed interference alignment scheme is optimal under the constraint of MAN placement for the four cases left open in [17] for the caching problem with multiple requests.
I-C Paper Organization
The rest of the paper is organized as follows.
The system model for the considered coded caching problem with correlated sources is given in Section II.
In Section III, our main results and some numerical evaluations are presented.
The proof of the proposed converse bound can be found in Section IV, and that of proposed achievable schemes in Section V. Section VI concludes the paper.
The proofs of some auxiliary results can be found in Appendix.
I-D Notation Convention
Calligraphic symbols denote sets,
bold symbols denote vectors,
and sans-serif symbols denote system parameters.
We use âŁâ
⣠to represent the cardinality of a set or the length of a vector;
[a:b]:={a,a+1,âŚ,b} and [n]:=[1,2,âŚ,n];
â represents bit-wise XOR.
II System Model
In a (N,K,r,M) shared-link caching problem with correlated files, a server has access to a library of NâN files (each of which contains BâN iid bits) denoted by {F1â,âŻ,FNâ}. The server is connected to KâN users through a shared error-free link. Each file is composed of (râ1Nâ1â) independent and equal-length blocks, where râ[N]; we denote
[TABLE]
where the block WSâ represents the exclusive common part across the files indexed by S. Hence, in the whole library there are (rNâ) independent blocks, each of which has B/(râ1Nâ1â) bits. A coded caching scheme has two phases: placement and delivery.
Placement Phase
During the cache placement phase, user kâ[K] stores information about the N files in its cache of size MB bits, where Mâ[0,N/r]. This phase is done without knowledge of usersâ demands.
We denote the content in the cache of user kâ[K] by Zkâ and let Z:=(Z1â,âŚ,ZKâ).
Delivery Phase
During the delivery phase, user kâ[K] demands file dkââ[N].
The demand vector d:=(d1â,âŚ,dKâ) is revealed to all nodes.
Given (d,Z), the server broadcasts a message X(d,Z)
of BR(d,Z) bits to all users.
User kâ[K] must recover its desired file Fdkââ from Zkâ and X(d,Z).
Load
For each demand vector d, we define N(T):={dkâ:kâT} as the set of demanded files by users in T, where Tâ[K].
A demand vector d is said to be of type DNeâ(d)â if it has Neâ(d):=âŁN([K])⣠distinct entries.
Based on the uniform demand distribution, the objective is to determine the optimal average load among all demands of the same type, that is
[TABLE]
and the optimal average load among all possible demands is
[TABLE]
Note that, with an abuse of notation, Râ(M)î =Esâ[Râ(M,s)] in general, unless the same cache placement policy optimizes the load in (2) for all sâ[min{K,N}].
Uncoded Cache Placement
The cache placement policy is said to be uncoded if each user directly copies some library bits directly into its cache. Under the constraint of uncoded cache placement, we can partition each block WSâ is partitioned into sub-blocks as
[TABLE]
where WS,Vâ represents the bits of WSâ which are exclusively cached by users indexed by V.
The optimal loads under the constraint of uncoded cache placement are denoted by Ruââ(M,s) and Ruââ(M) and are defined similarly to in (2) and (3), respectively.
Special Cases
Our model reduces to the MAN coded caching problem with average load when r=1, and to the case of a library with a single file when r=N. Both cases are either solved exactly or to within a factor of 2 in [4].
Relation to the More General Coded Caching Problem with Correlated Sources
In this paper, in order to make fundamental progress on the problem of caching correlated content, we simplified the model [12] as follows. In [12] a certain parameters â ranges from zero to the number of files in the system (each â1â files have a common part, each â2â files also have a common part, etc.), while in our model â is fixed to a single value r.
Our model is thus a special case of the one in [12].
With our models however, we can make conclusive statements (either exact capacity results, or capacity to within a constant multiplicative gap) which eluded in [12].
Relation to the Coded Caching Problem with Multiple Requests
If we identify the (rNâ) independent blocks as files of a library, and allow each cache-equipped user to request (râ1Nâ1â) such blocks/files, the considered caching problem with correlated sources relates to the symmetric caching problem with multiple requests considered in [15], where âsymmetricâ means that each user requests the same number of files. There is however a subtle difference between our model and the one in [15]: in our model one file corresponds to (râ1Nâ1â) distinct blocks, thus our model corresponds to the one in [15] under the constraint that a user has multiple but distinct requests. Moreover, here we consider the average load as our performance metric, while in [15] the authors used the worst-case load. Because of these differences, the results in this paper are not special cases of the results in [15].
The relationship among the two problems can be also explained as follows.
For the case of multiple requests, assume that the (rNâ) independent files are equally popular. On average, each of such independent files will appear on average the same number of times over the ensemble of all possible multiple request configurations. We construct N such multiple request configurations, each of which is formed by (râ1Nâ1â) independent files (in fact, each multiple request configuration corresponds to a âfileâ in the correlated file library of our problem). It follows that each independent file appears on average N(râ1Nâ1â)/(rNâ)=r times in the ensemble of possible multiple requests configurations. If instead of random multiple requests, we consider the deterministic symmetric case, where the possible multiple requests configurations are all and only those for which each independent files appears exactly r times (and not on average r times), we have the exact equivalence of our problem with the case of multiple requests of independent files.
With this interpretation, the proposed results in this paper also shed light into the very relevant and intricate problem of how to handle optimally the case where each user makes a sequence of requests of independent files (blocks). The fact that there are repeated elements in such sequence of requests is a âfundamentalâ aspect of caching (also in practice), where one needs to devise schemes that take advantage of previous requests and do not send the same stuff multiple times.
III Main Results and Numerical Evaluations
In this section, we state our main results and presents numerical evaluations of the proposed converse and achievable bounds. We shall use the subscripts âu,convâ and âu,achâ for converse (conv) and achievable (ach) bounds, respectively, under the constraint of uncoded cache placement (u).
III-A Converse Bound
Inspired by [23], we use the acyclic index coding converse bound from [22] to derive the following converse bound under the constraint of uncoded cache placement for our problem. The proof can be found in Section IV.
Theorem 1** (Converse).**
For a (N,K,r,M) shared-link caching problem with correlated files,
Ruââ(M,s), sâ[min{K,N}], is lower bounded by the lower convex envelope
of the following (M,R) pairs
[TABLE]
where
[TABLE]
In addition, Ruââ(M) is lower bounded by the lower convex envelope
of the following (M,R) pairs
[TABLE]
Theorem 1 for r=1 recovers the converse result for the MAN scheme under uncoded placement in [3], in particular the worst-case load is obtained for s=min{K,N} in (5), while the average load under uniform demands is given by (7).
Theorem 1 for r=N recovers the converse result for the MAN scheme with a single file, that is, ctsâ=1ât/KâşRâ(M)=1âM for Mâ[0,1].
III-B Achievable Scheme
Let M=KrNtâ for some integer tâ[0:K]. Recall that
we denoted by Neâ(d) the number of distinct files in the demand vector d, and by L(d)={u1â,âŚ,uNeâ(d)â} the set of chosen leader users.
We propose the following achievable scheme, which is analyzed in Section V.
[TABLE]
In the rest of this section we analyze the scheme in (8) in various settings of increasing order of complexity. Since the scheme is highly combinatorial, we shall start with a case that is the simplest to analyze and that brings to bear some of the key ideas. We shall then show that the a similar analysis applies also to more complex scenarios. In the following, optimality is understood under the constraint of uncoded cache placement. We have:
In Section III-C we show that the general scheme in (8) with only the first delivery sub-phase allows each leader user to decode its desired file. We also show the first sub-phase alone is exactly optimal when the users request different files, that is, all users are leaders, which is possible when Neâ(d)=Kâ¤N.
In Section III-D we show that the scheme in (8), with both delivery sub-phases, can satisfy every user regardless of the demand type, where the transmissions in sub-phase 2 are used to cancel the interferences experienced by the non-leader users. We also show its optimality to within a factor of 2 for any demand type.
In Section III-E we show that for some cases (such as, for example, the case of small or large memory size), each non-leader can re-construct the transmitted multicast messages in sub-phase 2 by performing linear combinations of the transmitted multicast messages in sub-phase 1, that is, sub-phase 2 is redundant. For these cases, we show exact optimality.
In Section III-F we show how the scheme in (8) can be used for other caching problems, by either offering simpler codes for the delivery phase than those known in the literature, or by providing an optimal scheme outperforming known state-of-the-art schemes.
In Section III-G we finally give some numerical evaluations of the proposed bounds.
III-C Optimality of (8) for demand type s=Kâ¤N
Here we consider the case where each user makes a distinct request, which requires Kâ¤N and demand type s=K=Neâ(d).
We propose a caching scheme where we jointly serve the usersâ demands. Existing methods approach the problem by serving requests in multiple rounds [12, 15, 16, 17], where each round is a MAN scheme with users having a single request. Our scheme here is as in (8), but where only the first sub-phase of the delivery phase takes place. In particular, for M=KrNtâ and s=Neâ(d)=Kâ¤N, our proposed delivery phase contains min{Nâr+1,Kât} steps, where in each step we transmit multicast messages to satisfy one leader user at a time. After all steps are done, the remaining users (who are also leaders, since here we consider a distinct request for each user) can also recover their desired file. The achieved load is presented in the following theorem, whose proof can be found in Section V-B.
Theorem 2** (Optimality for Distinct Requests).**
For a (N,K,r,M) shared-link caching problem with correlated files,
the loads in Theorem 1 are achievable under the constraint of uncoded cache placement when NâĽK=s by the scheme in (8) with only the first delivery sub-phase.
III-D Performance of (8) for any demand type
We analyze here the scheme in (8) with two sub-phases in the delivery phase, and show that it is able to satisfy general demands. The main ingredients of the schemes are as follows.
We pick a leader user among the users demanding the same file;
in the first delivery sub-phase, we generate multicast messages as in Theorem 2 so that each leader user can recover its desired file by the end of this sub-phase;
in the second delivery sub-phase, we transmit some additional multicast messages so that each non-leader user can cancel all non-intended (aligned interference) sub-blocks from all received multicast messages and thus can eventually recover its desired file.
The achieved load is presented in the following theorem, whose proof can be found in Section V-C.
Theorem 3** (Interference-Alignment Based Delivery Scheme).**
For a (N,K,r,M) shared-link caching problem with correlated files, an achievable memory-load tradeoff for any sâ[min{K,N}] is given by the lower convex envelope of the following (M,R) pairs
[TABLE]
where ctsâ is defined in (6) and
[TABLE]
In addition, Ruââ(M) is upper bounded by the lower convex envelope
of the following (M,R) pairs
[TABLE]
By comparing the converse bound in Theorem 1 and the achievable bound in Theorem 3, we have the following result, whose proof can be found in Section V-E.
Theorem 4** (Order Optimality for Theorem 3).**
For a (N,K,r,M) shared-link caching problem with correlated files, the loads in Theorem 3 are order optimal to within a factor of 2 under the constraint of uncoded cache placement.
III-E Optimality of (8) for râ{1,2,Nâ1,N} or tâ{0,1,2,Kâ1,K} or sâ[min{N,K,4}]
In Theorem 3,ctsâ in (6) is the load for the first delivery sub-phase while etsâ in (10) is the one for the second delivery sub-phase. Hence, compared to the converse bound in Theorem 1, etsâ is the term leading to the sub-optimality. In Theorem 2, where we showed exact optimality for distinct demands, the second sub-phase was not needed. We investigate here other cases where the second sub-phase is not needed. In particular, we show cases where each non-leader user can re-construct the multicast messages sent in sub-phase 2 by linearly combining multicast messages sent in sub-phase 1. Since in these cases the second delivery sub-phase is not necessary, we obtain the following exact optimality result proved in Section V-F.
Theorem 5** (Exact Optimality for Some Cases).**
For a (N,K,r,M) shared-link caching problem with correlated files, we have that Ruââ(M,s) and Ruââ(M) are equal to the lower convex envelops of (KrNtâ,ctsâ) and of (KrNtâ,Edâ[N]Kâ[ctNeâ(d)â]), respectively, where ctsâ is defined in (6), in the following cases:
-
Case 1 (small or large file correlation): when râ{1,2,Nâ1,N}, where optimality holds for any sâ[min{K,N}] and any tâ[0:K];
2. 2.
Case 2 (small or large cache size): when tâ{0,1,2,Kâ1,K}, where optimality holds for any sâ[min{K,N}] and any râ[N];
3. 3.
Case 3 (small number of distinct requests): when sâ[min{K,N,4}], where optimality holds for any râ[N] and any tâ[0:K]. In this case, no claim can be made on Ruââ(M) as only some values of s are exactly characterized.
From Theorem 5 we immediately have the following corollary, which can be proved straightforwardly by noting that Theorem 5.Case 3 covers all possible values of s when min(N,K)â¤4.
Corollary 1**.**
For a (N,K,r,M) shared-link caching problem with correlated files, the loads in Theorem 1 are achievable under the constraint of uncoded cache placement when min(N,K)â¤4 by the scheme in (8) with only the first delivery sub-phase.
Remark 1** (Average and Worst-case Loads).**
Our proposed caching scheme and our optimality results directly characterize the optimal worst-case load (and not just the average load), because the worst-case load is the case of demand type s=min{N,K}.
We note that past works only aimed to design schemes that minimize the worst-case load, such as those in [12] (for caching with correlated sources) and in [15, 16] (for caching with multiple requests).
Order optimality results (to within factors 11 and 18) on the worst-case load were derived in [15, 16] for caching with multiple requests;
to the best of our knowledge, no order optimality results are known specifically for caching with correlated sources.
Therefore, a major contribution of this paper, besides sharpening existing results for the worst-case load, it is to have derived (exact or order) optimality results on the average loads for any demand type and over all possible demands, under the constraint of uncoded cache placement.
âĄ
III-F Extensions
Our scheme can be used in models other than the one considered in this paper.
Examples are as follows.
Extension to the More General Coded Caching Problem with Correlated Sources
As already mentioned earlier, in this paper
we simplified the model [12]
by fixing the parameter â in [12] to be equal to r (as opposed to let be to within a range).
We can extend our results to the case where â is within a range as follows.
If â is in a range as considered in [12], we can construct a caching scheme by âmemory-sharingâ among the proposed schemes in Theorems 2, 3, and 5 as follows.
Library.
Assume that the length of each block WSâ, where Sâ[N] and âŁSâŁ=â, is pââB/(âNâ), where pâââ[0,1] and âââ[N]âpââ=1. The values (pââ:ââ[N]) are assumed to be fixed system parameters.
Placement.
Choose integers tâââ[K] for ââ[N], We partition block WSâ into (tâŁSâŁâKâ) equal-length sub-blocks and denote WSâ={WS,Vâ:Vâ[K],âŁVâŁ=tâŁSâŁâ}.
User kâ[K] caches sub-block WS,Vâ if kâV, which requires a cache of size
[TABLE]
Delivery.
For demand vector d, if Neâ(d)=K (i.e., each user demands a distinct file), we use the caching scheme in Theorem 2 and the achieved load is
[TABLE]
If s=Neâ(d)<K we have two cases;
if either ââ{1,2,Nâ1,N} or tâââ{0,1,2,Kâ1,K}, we use the caching scheme in Theorem 5 to encode all blocks; otherwise, we use the caching scheme in Theorem 3; the achieved load is
[TABLE]
where \mathbbm1 is the indicator function, where \mathbbm1eventâ=1 if event is true and \mathbbm1eventâ=0 otherwise.
The achievable memory-load tradeoff is the lower convex envelope of the above points for all possible t:=(tââ:ââ[N]).
Extension to the Coded Caching Problem with Multiple Requests
In this paper, differently from most of the existing work that divides the multi-request problem into a sequence of single-request problems, we can modify our proposed interference alignment scheme for the caching problem with correlated sources to address the caching problem with multiple requests.
By doing so, we can give an optimal scheme for the four cases that were left open in [17] for the caching problem with multiple requests, where the setting includes up to four users and where each user demands at most two files.
The details of how to modify our proposed interference alignment scheme (so as to account for the lack of symmetry of the multi-request problem) are given in Appendix G.
Extension to Distributed Computation
When N=K and each user demands a distinct file, the (N,K,r,M) shared-link caching problem with correlated files is related to the distributed computation problem in [24]. The only difference is that in [24] the link is D2D (i.e., workers/users communication among each other without a central master/server), as opposed to the shared-link case considered here.
In [24], the authors proposed an optimal scheme that requires to exchange messages where symbols are from a large finite field size. In the contrast, for the shared-link caching problem, by using the optimal scheme proposed in this paper, operations are simpler in that they are on the binary field.
III-G Numerical Evaluations
In Figs. 1 and 2 we plot the load vs the cache size for demand types D20â (left subfigure) and D10â (right subfigure) for the (N,K)=(20,40) shared-link caching problem with correlated files.
In Fig. 1 we consider the r=2, for which our proposed scheme (with only the first delivery sub-phase) is optimal as stated in Theorem 5.
We also compare the average loads achieved by our scheme in Theorem 5 with that of the suboptimal scheme in [12].
In Fig. 2 we consider the r=3.
When t=KMr/Nâ{0,1,2,39,40}, only the first sub-phase of the delivery scheme is necessary and the resulting load is optimal as stated in Theorem 5. For other values of the parameter t, we use both sub-phases of the delivery scheme as in Theorem 3. Fig. 2 shows that our proposed achievable scheme outperforms the scheme in [12].
In Fig. 3 we plot the average load over all possible demands for the (N,K,r)=(30,30,5) shared-link caching problem with correlated files, by Monte-Carlo simulation with the number of
iteration 106. In each iteration, the demand of each user is generated independently at random based on the discrete uniform distribution.
When t=KMr/Nâ{0,1,2,28,29} or Neâ(d)â¤4, only the first sub-phase of the delivery scheme is necessary and the resulting load is optimal as stated in Theorem 5. For other values of the parameters t and Neâ(d), we use both sub-phases of the delivery scheme as in Theorem 3. Fig. 3 shows that our proposed achievable scheme outperforms the scheme in [12].
IV Converse Bound
IV-A Proof of Theorem 1
The delivery phase with uncoded cache placement is equivalent to a multicast index coding problem [25]. Such a problem can be represented on a directed graph. In this graph, each sub-block demanded but not cached by a user is a node; a directed edge exists from node a to node b if the user demanding the sub-block represented by node b has the sub-block represented by node a in its cache.
As in [23], we use the acyclic index coding converse bound from [22] to lower bound the number of transmitted bits needed to satisfy all the nodes/users in this index coding problem as follows.
For a demand vector d, with Neâ(d) distinct demands, we draw a graph where each sub-block demanded but not cached by some of these Neâ(d) users is node. We then consider a permutation of these Neâ(d) users, denoted by u=(u1â,u2â,...,uNeâ(d)â).
The set of sub-blocks
[TABLE]
does not contain a directed cycle.
This can be seen as follows, similarly to [2, Lemma 1].
We classify the sub-blocks/nodes in the set (15) into levels. More precisely,
we say that sub-block/node WS,Vâ is in level i if Sâ[N]â{du1ââ,âŚ,duiâ1ââ}, duiâââS and Vâ[K]â{u1â,âŚ,uiâ}. It is easy to see each node in level i
is a sub-block that is demanded but not-cached by user uiâ that did not appear in any of the levels with lower index, and corresponds to a user in the index coding problem that has the same side information as user uiâ in our caching problem (i.e., each node in level i only knows the nodes WS,Vâ where uiââV). So each node in level i knows neither the nodes in the same level, nor the nodes in the higher levels. As a result, the proposed set in (15) does not contain a directed cycle.
By the acyclic index coding converse bound, the number of transmitted bits is not less than total number of bits of the sub-blocks in the set in (15), that is,
[TABLE]
where âŁWS,Vâ⣠represents the length of WS,Vâ in bits.
[TABLE]
As in [3], we can lower bound (17e) by using Jensenâs inequality and the monotonicity of Conv(ctsâ) (i.e., the convex lower envelope of ctsâ in terms of t),
[TABLE]
By considering all the demand types, and from (18), we also have
[TABLE]
Since ctsâ is convex in t, we can change the order of the expectation and the âConvâ in (19). Thus we prove the converse bound in Theorem 7.
Notice that we could also use Fourier-Motzkin elimination to eliminate the parameters {xtâ}tâ[0:K]â in (17e) and derive the bound in (18), as done in [23].
IV-B Discussion
We conclude this session with some observations on the proposed converse bound, which we shall use as a guideline to design our achievable schemes.
-
The corner points of our converse bound are of the form (KrNtâ,ctsâ), where ctsâ is defined in (6), which may suggest the following placement.
We partition each block WSâ into (tKâ) equal-length sub-blocks of length (râ1Nâ1â)(tKâ)Bâ and indicate WSâ={WS,Vâ:Vâ[K],âŁVâŁ=t}.
Each user kâ[K] stores the sub-block WS,Vâ if kâV.
Hence, user kâ[K] caches (râ1Nâ1â)(tKâ)B(tâ1Kâ1â)(rNâ)â=KrBNtâ bits in total.
We will use this interpretation to design the file partitioning and the cache placement of our proposed caching schemes, which is the same as in [12].
2. 2.
If the above placement is used, each sub-block is cached by t users.
In the proof of Theorem 1, for each demand d, we choose a set of leader users (each demanding a differenet file) and consider a permutation u=(u1â,âŚ,uNeâ(d)â) of these Neâ(d) leader users.
For the permutation u, we find an acyclic set of âjâ[min{Neâ(d),Nâr+1,Kât}]â(râ1Nâjâ)(tKâjâ) sub-blocks, and lower bounded the load by the total length of these sub-blocks.
In addition, in this acyclic set of sub-blocks, there are (râ1Nâjâ)(tKâjâ) sub-blocks desired by user ujâ where jâ[min{Neâ(d),Nâr+1,Kât}]; these sub-blocks are not cached nor desired by any user uj1ââ where j1â<j. This may suggest a delivery scheme with min{Neâ(d),Nâr+1,Kât} steps, where in Step j we transmit (râ1Nâjâ)(tKâjâ) linear combinations such that each linear combination contains one of the (râ1Nâjâ)(tKâjâ) sub-blocks desired by user ujâ, and thus at the end of this step user ujâ is satisfied.
We will use this interpretation to design the first sub-phase of our general delivery scheme in (8), which we shall introduced next in Section V.
V Achievable Scheme
In this section, we analyze the achievable scheme in (8) and prove the statements of Theorems 2, 3 and 5.
Notice that when râ{1,N}, the considered problem is equivalent to the MAN problem (solved under the constraint of uncoded cache placement in [3]). Hence, the novelty of our schemes is for râ[2:Nâ1].
The scheme we propose was summarized in (8);
Theorems 2 and 5 only use the first sub-phase of the delivery, while
Theorem 3 uses both sub-phases.
The rest of this section is organized as follows.
In Section V-A we give an example of the first sub-phase of the proposed delivery scheme in (8); the objective is to highlight how the multicast messages sent in sub-phase 1 enable all leaders to decode their desired file. Then in Section V-B we show which user can decode which sub-block after receiving the multicast messages in sub-phase 1, regardless of the demand type.
In Section V-C we show that every user can decode its desired message by also receiving the multicast messages sent in sub-phase 2. In Section V-D we give an example of the second sub-phase of the proposed delivery scheme in (8).
In Section V-E we prove the order optimality results in Theorems 4 for general case.
Finally, in Section V-F we prove the exact optimality results in Theorem 5 by observing each non-leader can re-construct the packets of sub-phase 2 by performing linear combinations of the the received packets in sub-phase 1.
V-A An example of (8) with only sub-phase 1 for the delivery scheme
First, we study an example where NâĽK and where each user demands a distinct file (i.e., s=K).
In particular, we consider the (N,K,r,M)=(4,4,2,1/2) shared-link caching problem with correlated files.
There are (rNâ)=6 blocks denoted as W{1,2}â, W{1,3}â, W{1,4}â, W{2,3}â, W{2,4}â, and W{3,4}â.
The files are
[TABLE]
Block Subdivision
Here t=NKMrâ=1.
We partition each block into (tKâ)=4 equal-length sub-blocks and denote
WSâ={WS,Vâ:Vâ[K],âŁVâŁ=t=1}={WS,{k}â:kâ[K]}.
Hence, each sub-block contains {\mathsf{B}}/\Big{(}\binom{{\mathsf{N}}-1}{{\mathsf{r}}-1}\binom{{\mathsf{K}}}{t}\Big{)}={\mathsf{B}}/12 bits.
Placement Phase
The cache placement is inspired by the converse bound (see discussion in Section IV-B).
User kâ[K] caches WS,Vâ if kâV, that is, Zkâ={WS,{k}â,âSâ[N]:âŁSâŁ=r=2}.
Delivery Phase
Assume d=(1,2,3,4), which has Neâ(d)=4 distinct demanded files. Pick one user demanding a distinct file, and refer to it as the leader among those users demanding the same file. Since each user has a distinct request in this example, each user is a leader, and the leader set is [4].
Consider a permutation u of the leaders, say u=(1,2,3,4).
Our proposed first sub-phase of the general delivery scheme contains min{Neâ(d),Nâr+1,Kât}=3 steps;
after the jth step, the jth element/leader in the permutation can decode its desired file;
after finishing all steps, the remaining leaders can also decode their desired file.
We next describe, one by one, the three steps in the delivery phase for this example,
where each step we send multicast messages of the type
[TABLE]
where N(J) is the set of demanded files by the users in J.
In plain words, the multicast message CT,Hâ in (20) is the binary sum of each sub-block desired by one user in J and known by all the other users in J.
Note that, when r=1 (in which case our model reduces to the MAN system in [1]),
CT,â
â in (20) is equivalent to the MAN multicast message
[TABLE]
Delivery Sub-Phase 1.Step 1.
In this step we aim to satisfy leader user u1â=1, who misses three sub-blocks of the three blocks the made up the first file, that is, user 1 must recover nine sub-blocks.
Each time we consider one set of users Jâ[K] where âŁJâŁ=t+1=2 and u1ââJ (recall that u1â=1), and one set of files Bâ[N]â{du1ââ} (recall that du1ââ=1) where âŁBâŁ=râ1=1.
[TABLE]
From (22) and its cached content, user u1â=1 can recover W{1,2}â, W{1,3}â, and W{1,4}â.
User u1â=1 is satisfied after this first step (i.e., it has recovered the missing nine sub-blocks from the nine received multicast messages in the first step).
Let us then focus on user u2â=2. User 2 can directly recover W{1,2},{1}â from (22a), W{2,3},{1}â from (22b), W{2,4},{1}â from (22c). Since user 2 has recovered W{2,3},{1}â, it then can recover W{1,2},{3}â from (22d). Since user 2 has recovered W{2,4},{1}â, it then can recover W{1,2},{4}â from (22g). In conclusion, after Step 1, user 2 can recover W{1,2}â and also recover W{2,3},{1}â and W{2,4},{1}â.
User u2â=2 after this first step still misses four sub-blocks, namely {W{2,3},{k}â,W{2,4},{k}â:kâ[3,4]}.
Similarly to user u2â=2, each user kâ{2,3,4} can recover WSâ where {du1ââ,dkâ}âS, and can also recover WS1â,V1ââ where dkââS1â and u1ââV1â, after Step 1.
Each of these users still misses four sub-blocks.
Delivery Sub-Phase 1.Step 2.
In this step we aim to satisfy leader user u2â=2.
Each time we consider one set of users Jâ([K]â{u1â}) where âŁJâŁ=t+1 and u2ââJ, and one set of files Bâ([N]â{du1ââ,du2ââ}) where âŁBâŁ=râ1=1 (recall that u1â=du1ââ=1,u2â=du2ââ=2).
[TABLE]
From (23) user u2â=2 can recover the desired sub-blocks that were not recovered from Step 1.
User u2â=2 is satisfied after this second step (i.e., it has recovered the missing four sub-blocks from the four received multicast messages in the second step).
Let us then focus on user u3â=3. User 3 can directly recover W{2,3},{2}â from (23a) and W{3,4},{2}â from (23b). Since user 3 has recovered W{3,4},{2}â, it then can recover W{2,3},{4}â from (23c).
User u3â=3 after this second step still misses W{3,4},{4}â.
Similarly to user u3â=3, at the end of Step 2, each user kâ{3,4} can recover WSâ where dkââS, {du1ââ,du2ââ}âŠSî =â
, and also recover WS1â,V1ââ where dkââS1â and {u1â,u2â}âŠV1âî =â
.
Each of these users still misses one sub-block.
Delivery Sub-Phase 1.Step 3.
In this step we aim to satisfy leader user u3â=3.
Each time we consider one set of users Jâ([K]â{u1â,u2â}) where âŁJâŁ=t+1 and u3ââJ, and one set of files Bâ([N]â{du1ââ,du2ââ,du3ââ}) where âŁBâŁ=râ1=1 (recall that u1â=du1ââ=1,u2â=du2ââ=2,u3â=du3ââ=3).
Hence, at this point there is one possibility, J={3,4} and B={4}, for which we transmit
[TABLE]
From (24), user 3 can recover W{3,4},{4}â, and user 4 can recover W{3,4},{3}â.
Hence, at the end this third step, users 3 and 4 are satisfied (i.e., they recovered the missing sub-block from the received multicast message in the third step).
Performance
Based on the above placement and delivery scheme, all users are able to decode their desired blocks.
We sent âjâ(râ1Nâjâ)(tKâjâ)=14 linear combinations, each of length B/12 bits. So the load is 7/6, which coincides with the converse bound in Theorem 1 for s=4.
Comparison with state-of-the-art âround-divisionâ schemes
Let us then consider the round-division methods in [12, 15, 16, 17]. It is obvious that if there exists some sub-block appearing in different rounds, a round-division strategy that treats each round as an independent MAN caching problem with a single request may miss some multicast opportunities. Here we show that a round-division strategy is sub-optimal even if we can divide usersâ demands into multiple rounds such that there does not exist any sub-block appearing in different rounds.
More precisely, since each user demands 3 blocks, we can divide the delivery into the following three rounds:
Round 1:
In the first round, users 1 and 2 demand W{1,2}â, and users 3 and 4 demand W{3,4}â. This is equivalent to the MAN caching problem with 4 users and 2 files. By using the optimal caching scheme under the constraint of uncoded cache placement in [3], we need to transmit (tKâ)â(tKâNâ)=(24â)â(22â)=5 linear combinations, each of which contains B/12 bits, in order to satisfy these requests.
Round 2:
In the second round, users 1 and 3 demand W{1,3}â, and users 2 and 4 demand W{2,4}â. By using the caching scheme in [3], we need to transmit 5 linear combinations to satisfy these requests.
Round 3:
In the third round, users 1 and 4 demand W{1,4}â, and users 2 and 3 demand W{2,3}â. By using the caching scheme in [3], we need to transmit 5 linear combinations to satisfy these requests.
Hence, by this round-division strategy, the load is 15/12>7/6, which is strictly sub-optimal.
In conclusion, in order to achieve optimality in this example, we need to jointly serve usersâ demands (as proposed in this paper) in order to fully leverage all multicast opportunities.
V-B Proof of Theorem 2
Here we shall prove that after the first sub-phase of the delivery scheme in (8) every leader user is able to decode its desired file (as in the example in Section V-A), and that the load of the first sub-phase matches the load of the converse bound in (6). Thus, for the case where every user is a leader (i.e., every user demands a distinct file, as in the example in Section V-A), we have proved the exact optimality under the constraint of uncoded cache placement of the proposed achievable scheme as claimed in Theorem 2.
Decodability after delivery sub-phase 1
We need to establish which user can decode which sub-block at each step of delivery sub-phase 1.
The following Lemma 1, which is proved by induction in Appendix A, describes the decoding procedure for delivery sub-phase 1 for general demands. Lemma 1 is the most technical (i.e., highly combinatorial) contribution in this paper.
Lemma 1** (Decoding after sub-phase 1).**
In the first sub-phase of the proposed delivery scheme in (8) with leader set {u1â,âŚ,uNeâ(d)â},
in Step jâ[min{Neâ(d),Nâr+1,Kât}],
for each set of users J111Please note that here we write the set in the first subscript of CJ,Bâ is an equivalent but slightly different form compared to (8f).
where Jâ[K]â{u1â,âŚ,ujâ1â} such that âŁJâŁ=t+1 and ujââJ, and
for each set of files Bâ[N]â{du1ââ,âŚ,dujââ} where âŁBâŁ=râ1, we transmit CJ,Bâ as defined in (20).
Note that by construction (i.e., âŁBâŁ=râ1 and dujâââ/B), CJ,Bâ contains only one sub-block desired by user ujâ (which is W{dujââ}âŞB,Jâ{ujâ}â), while all other sub-blocks are cached by user ujâ.
Let ug(i)â represent the leader user who demands file iâL(d).
At the end of the first delivery sub-phase, we have:
-
For a (J,B), each user in J can recover all the sub-blocks in CJ,Bâ.
2. 2.
At the end of Step jâ[min{g(dkâ),Nâr+1,Kât}], user kâ[K] can recover WS1â,V1ââ
if dkââS1â and {u1â,âŚ,ujâ}âŠV1âî =â
.
3. 3.
At the end of Step jâ[min{g(dqâ)â1,Nâr+1,Kât}], user qâ[K] can recover WSâ
if dqââS and {du1ââ,âŚ,dujââ}âŠSî =â
.
Decodability for leader users after sub-phase 1
We use Lemma 1 to show that every leader user is able to recovered its demanded file after delivery sub-phase 1. Indeed, for any system parameters, for leader user upâ, where pâ[Neâ(d)], we have:
Case pâ¤min{Neâ(d),Nâr+1,Kât}.
From Lemma 1.Item 3 , user upâ can recover WSâ, where dupâââS and {du1ââ,âŚ,dupâ1ââ}âŠSî =â
, at the end of Step pâ1.
In addition, from Lemma 1.Item 2 , user upâ can also recover WS1â,V1ââ, where dupâââS1â and {u1â,âŚ,upâ1â}âŠV1âî =â
, at the end of Step pâ1.
Hence, user upâ still needs to recover WS2â,V2ââ, where dupâââS2â, {du1ââ,âŚ,dupâ1ââ}âŠS2â=â
and {u1â,âŚ,upâ}âŠV2â=â
, at the end of Step pâ1 (recall that WS2â,V2ââ where upââV2â is cached by user upâ). Such a WS2â,V2ââ appears in CV2ââŞ{upâ},S2ââ{dupââ}â, which is sent in Step p.
Hence, from Lemma 1.Item 1 , user upâ can recover WS2â,V2ââ at the end of Step p.
Case Neâ(d)>min{Nâr+1,Kât} and min{Nâr+1,Kât}<pâ¤Neâ(d).
We distinguish two cases:
If Nâr+1â¤Kât, it can be seen that for each desired block of user upâ (assumed to be WSâ), we have SâŠ{du1ââ,âŚ,duNâr+1ââ}î =â
, and thus from Lemma 1.Item 3 , user upâ can recover WSâ.
If Nâr+1>Kât, it can be seen that for each desired sub-block of user upâ (assumed to be WS1â,V1ââ), we have V1ââŠ{u1â,âŚ,uNâr+1â}î =â
, and thus from Lemma 1.Item 2 , user upâ can recover WS1â,V1ââ.
This proves that each leader can recover its demanded file after sub-phase 1.
Load of sub-phase 1
This proposed sub-phase 1 of the delivery scheme contains (râ1Nâjâ)(tKâjâ) multicast messages in Step jâ[min{Neâ(d),Nâr+1,Kât}], which follows the intuition from the proof of our converse bound (see discussion in Section IV-B). Thus, by summing over all steps in sub-phase 1, we get that the load of this delivery sub-phase matches the load of the converse bound in (6).
Optimality for the case of distinct demands
From the above reasoning, when all users are leaders, that is for the case NâĽK and demand type s=K, the claim of Theorem 2 is proved, i.e., every user is satisfied at the end of sub-phase 1, whose load matches the converse bound.
V-C Proof of Theorem 3
Here we shall prove that after the two sub-phases of the delivery scheme in (8) every user is able to decode its desired file. This requires showing that after the second sub-phase the demands of all non-leader users are satisfied. Sub-phase 2 of the delivery scheme in (8) is a form of interference alignment.
The block split and the cache placement phase are as described in (8).
The delivery phase contains two sub-phases, where the first sub-phase is the same as in Section V-B, and the second sub-phase is such that non-leader can align or cancel the non-demanded sub-blocks and eventually decode their demanded file. We specify next what each user can decode at the end of each step.
First Delivery Sub-Phase
In Step jâ[min{Neâ(d),Nâr+1,Kât}] of the first sub-phase, for each set of users Jâ[K]â{u1â,âŚ,ujâ1â} where âŁJâŁ=t+1 and ujââJ, and each set of files Bâ[N]â{du1ââ,âŚ,dujââ} where âŁBâŁ=râ1, we transmit CJ,Bâ as defined in (20).
As shown in Section V-B, at the end of this sub-phase, each leader can recover its desired file.
In addition, from Lemma 1, recalling that ug(i)â represent the leader user who demands file i,
each non-leader user kâ[K]âL(d) can decode WSâ, where dkââS and {du1ââ,âŚ,dug(dkâ)â1ââ}âŠSî =â
, and can decode WS1â,V1ââ where dkââS1â and {u1â,âŚ,ug(dkâ)â}âŠV1âî =â
.
The non-leader users are thus not yet satisfy, and thus we proceed to send further multicast messages in sub-phase 2.
Second Delivery Sub-Phase
The second sub-phase also contains min{Neâ(d),Nâr+1,Kât} steps. In Step j, each time we focus on one integer qâ[j+1:min{Nâr+2,Kât+1,Neâ(d)}].
For each Jâ˛â[K]â{u1â,âŚ,uqâ} where âŁJâ˛âŁ=tâ1 and Jâ˛âŠ{uq+1â,âŚ,uNeâ(d)â}î =â
, and each Bâ˛â[N]â{du1ââ,âŚ,duqââ} where âŁBâ˛âŁ=râ2 and Bâ˛âŠN([K])î =â
, we transmit CJâ˛âŞ{ujâ,uqâ},Bâ˛â as defined in (20).
We describe next how each non-leader users can recover the demanded file by combining the multicast messages from both sub-phases. The decoding is rather involved, thus we break down the key steps into lemmas that are proved in Appendix.
In Step j of the second sub-phase, the transmitted multicast message CJâ˛âŞ{ujâ,uqâ},Bâ˛â by construction satisfies Jâ˛âŠ{uq+1â,âŚ,uNeâ(d)â}î =â
;
however, non-leader user k also needs multicast message such that Jâ˛âŠ{uq+1â,âŚ,uNeâ(d)â}=â
.
It is proved in Appendix B
that each user k who demands Fdujâââ can reconstruct CJâ˛âŞ{ujâ,uqâ},Bâ˛â, where Jâ˛âŠ{uq+1â,âŚ,uNeâ(d)â}=â
by using previously received multicast messages, as formalized in the next lemma.
Lemma 2**.**
In Step jâ[min{Neâ(d),Nâr+1,Kât}] of sub-phase 2, for any integer qâ[j+1:min{Nâr+2,Kât+1,Neâ(d)}], each Jâ˛â[K]â{u1â,âŚ,uNeâ(d)â} where âŁJâ˛âŁ=tâ1, and each Bâ˛â[N]â{du1ââ,âŚ,duqââ} where âŁBâ˛âŁ=râ2 and Bâ˛âŠN([K])î =â
, user k who demands dujââ can obtain CJâ˛âŞ{ujâ,uqâ},Bâ˛â by making linear combinations of already received multicast messages.
The following Lemma 3, whose proof is in Appendix C, specifies some properties of the linear combinations CT,Hâ defined in (20).
Lemma 3** (Properties of function CT,Hâ defined in (20)).**
For each Jâ[K] where âŁJâŁ=t+1, and each Bâ[N] where âŁBâŁ=râ1, we have
[TABLE]
for any iâB where ug(i)ââ/J. In addition, for each J1ââ[K] where âŁJ1ââŁ=t+1, and each B1ââ[N] where âŁB1ââŁ=râ1 and N(J1â)âŠB1âî =â
, we have
[TABLE]
for any i1ââN(J1â)âŠB1â.
From Lemma 3, we prove the following Lemma 4 (whose proof is in Appendix D), which is the key result for our interference alignment based delivery scheme. Recall that L(d) denotes the set of leader users.
Lemma 4** (Interference alignment lemma).**
For each jâ[min{Neâ(d),Nâr+1,Kât}] and each iâ{du1ââ,âŚ,dujââ},
any non-leader kâ[K]âL(d) can reconstruct CJ2ââŞ{ujâ},B2ââŞ{i}â where J2ââ[K]â{u1â,âŚ,ujâ}, âŁJ2ââŁ=t, B2ââ[N]â{du1ââ,âŚ,dujââ}, âŁB2ââŁ=râ2, and N(J2ââŠL)âB2âî =â
.
Lemma 4 can be understood as follows.
After the first sub-phase, the remaining sub-blocks to be decoded for each non-leader kâ[K]âL(d) are WS2â,V2ââ where dkââS2â, {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
and {k,u1â,âŚ,ug(dkâ)â}âŠV2â=â
.
In Step g(dkâ) of the first sub-phase, the transmitted message CJ,Bâ should satisfy dg(dkâ)ââ/B. From Lemma 4, we show user k can also reconstruct CJâ˛,Bâ˛â where dg(dkâ)ââBâ˛. Since dug(dkâ)âââBâ˛, each sub-block in CJâ˛,Bâ˛â is desired or cached by user k who demands Fkâ. In other words, in order to reconstruct CJâ˛,Bâ˛â, we align/cancel the interferences to user k. By induction, all sub-blocks except one in CJâ˛,Bâ˛â have been already recovered or cached by user k such that it can recover that sub-block. The details of the decodability proof is presented in Appendix E.
An example of how the interference alignment scheme works is given in Section V-D.
Performance
As we showed in Section V-B, in the first sub-phase we transmit ctsâ bits, with s=Neâ(d).
In Step jâ[min{s,Nâr+1,Kât}], s=Neâ(d), of the second sub-phase, the number of transmitted bits is
[TABLE]
Hence, by summing the number of transmitted bits in each step of sub-phase 2 and the number of transmitted bits in sub-phase 1, the load equals etsâ+ctsâ as defined in (6) and (10), with s=Neâ(d).
This concludes the proof of Theorem 3.
V-D An example of sub-phase 2 in (8)
We will use the following example to illustrate our interference alignment scheme.
Consider an (N,K,M,r)=(5,10,1/2,3) shared-link caching problem with correlated files.
There are (rNâ)=10 blocks, WSâ where Sâ[5] and âŁSâŁ=r=3.
The files are
[TABLE]
Placement Phase
Here t=NKMrâ=3.
We partition each block into (tKâ)=120 equal-length sub-blocks and denote WSâ={WS,Vâ:Vâ[K],âŁVâŁ=t=3}.
Each user kâ[K] caches WS,Vâ if kâV.
Delivery Phase
Assume d=(1,2,3,4,5,1,2,3,4,5), which has Neâ(d)=5 distinct demanded files.
We choose as leaders the users in u=(1,2,3,4,5).
First delivery sub-phase
In Step jâ[min{Neâ(d),Nâr+1,Kât}]=[3] of the first sub-phase, for each set of users Jâ[K]â[jâ1] where âŁJâŁ=t+1=4 and jâJ, and each set of files Bâ[N]â[j] where âŁBâŁ=râ1=2, we transmit CJ,Bâ.
At the end of the first sub-phase, as shown in Section V-B, each leader user can recover its desired file.
For the non-leaders, we focus on user 6. From Lemma 1, user 6 can decode WS1â,V1ââ where 1âS1â and 1âV1â. Hence, after the first sub-phase, user 6 still needs to recover WS2â,V2ââ where 1âS2â and {1,6}âŠV2â=â
. Similarly, each non-leader user kâ[6:10] still needs to recover WS2â,V2ââ where dkââS2â, {1,âŚ,dkââ1}âŠS2â=â
, and {k,1,âŚ,dkâ}âŠV2â=â
(recall that g(dkâ)=dkâ in this example).
Second delivery sub-phase
In Step jâ[3] of the second sub-phase, for each qâ[j+1:4], each Jâ˛â[K]â[q] where âŁJâ˛âŁ=tâ1=2 and Jâ˛âŠ[q+1:5]î =â
, and each Bâ˛â[N]â[q] where âŁBâ˛âŁ=râ2=1, we transmit
CJâ˛âŞ{j,q},Bâ˛â.
We now prove the decodability of user 6. Observe that leader g(d6â)=1 also demands F1â, we show the decodability of user 6 by induction. For each jâ[g(d6â)+1:Neâ(d)]=[2:5], we prove user 6 can recover its desired sub-block WS2â,V2ââ where dujâââS2â or ujââV2â.
We start from j=2.
In the following, we show user 6 can recover W{1,2,3},V2ââ where {1,6}âŠV2â=â
by interference alignment decoding (i.e., W{1,2,3},{2,3,4}â, W{1,2,3},{2,3,5}â, W{1,2,3},{2,4,5}â, and W{1,2,3},{3,4,5}â). A similar argument applies to every non-leader user kâ[6:10].
We first focus on W{1,2,3},V2ââ where {g(d6â),6}={1,6}â/V2â and ujâ=2âV2â, e.g., W{1,2,3},{2,3,4}â. In Step 1 of the first sub-phase, user 6 receives
[TABLE]
By summing (28) and (29), we can obtain
[TABLE]
which shows the property in (26) in Lemma 4.
It can be seen by summing (28) and (29), we cancel the interferences from the sub-blocks of W{2,3,4}â to user 6. From Lemma 1, user 6 can decode WS1â,V1ââ where 1âS1â and 1âV1â. In addition, in
[TABLE]
which is transmitted in Step 2 of the first sub-phase, user 6 caches all except W{1,3,4},{2,3,4}â such that it can recover W{1,3,4},{2,3,4}â by directly reading off.
Hence, user 6 has decoded all except W{1,2,3},{2,3,4}â in (30) such that it can recover W{1,2,3},{2,3,4}â.
By similar steps, for each desired sub-block W{1,2,3},V2ââ where {1,6}âŠV2â=â
and ujâ=2âV2â, user 6 first reconstructs CV2ââŞ{1},{1,2,3}â{2}â and then recovers W{1,2,3},V2ââ from CV2ââŞ{1},{1,2,3}â{2}â.
We then focus on W{1,2,3},V2ââ where {g(d6â),6}âŞ{ujâ}={1,2,6}âŠV2â=â
, e.g.,
W{1,2,3},{3,4,5}â. In Step 1 of the first sub-phase, user 6 receives
[TABLE]
In Step 1 of the second sub-phase (with j=1, q=2, Jâ˛={4,5}, Bâ˛={3}), user 6 receives
[TABLE]
By summing (32)-(36), we have
[TABLE]
which shows the property in (25) in Lemma 4.
Hence, by (38), user 6 can reconstruct C{2,3,4,5},{1,3}â while cancelling the interferences in (32)-(36), coinciding with Lemma 4. We then focus on each sub-block in C{2,3,4,5},{1,3}â. W{1,2,3},{2,4,5}â can be recovered by user 6 as we showed previously for W{1,2,3},{2,3,4}â. For W{1,3,4},{2,4,5}â, in
[TABLE]
which is transmitted in Step 2 of the first sub-phase, user 6 caches all except W{1,3,4},{2,4,5}â such that it can recover W{1,3,4},{2,4,5}â by directly reading off. Similarly, user 6 can recover W{1,3,4},{2,3,5}â, W{1,3,5},{2,4,5}â, and W{1,3,5},{2,3,4}â from Step 2 of the first sub-phase by directly reading off. Hence, in C{2,3,4,5},{1,3}â, user 6 has recovered all except W{1,2,3},{3,4,5}â such that user 6 can recover W{1,2,3},{3,4,5}â.
Finally, we consider W{1,2,3},{3,9,10}â, where d9â=4 and d10â=5.
Notice that, C{1,2,9,10},{3}â
is not transmitted in the second sub-phase, because both of users 9,10 are not leaders,
which contradicts the constraint on the transmission of the second sub-phase (Jâ˛âŠ[q+1:5]î =â
with q=2 and Jâ˛={9,10}).
However, it can be seen that if user 6 can reconstruct C{1,2,9,10},{3}â, by the same decoding procedure as W{1,2,3},{3,4,5}â, user 6 can recover W{1,2,3},{3,9,10}â. So in the following, we prove user 6 can reconstruct C{1,2,9,10},{3}â, as described in Lemma 2.
Notice that C{1,2,4,10},{2,3}â and C{1,2,4,10},{3}â are transmitted in Step 1 of the first and second sub-phases, respectively. Hence, user 6 can obtain
[TABLE]
On the RHS of (40), W{1,3,4},{2,4,10}â and W{1,3,5},{2,4,10}â can be recovered by user 6 from C{2,4,6,10},{3,4}â and C{2,4,6,10},{3,5}â transmitted in Step 2 of the first sub-phase, respectively (by directly reading off). W{1,3,4},{1,2,10}â and W{1,3,5},{1,2,4}â can be recovered by user 6 because they are cached by user 1 and thus we can use Lemma 1.Item 2. Hence, from (40), user 6 can recover
[TABLE]
Similarly, user 6 can recover
[TABLE]
from C{1,2,4,5},{2,3}ââC{1,2,4,5},{3}â and C{1,2,8,5},{2,3}ââC{1,2,8,5},{3}â, respectively. By summing (41)- (43), user 6 can obtain
[TABLE]
Similar to (40), we have
[TABLE]
On the RHS of (45), C{1,2,9,10},{2,3}â is transmitted in Step 1 of the first sub-phase.
In addition, W{1,3,4},{2,9,10}â and W{1,3,5},{2,9,10}â can be recovered by user 6 from C{2,6,9,10},{3,4}â and C{2,6,9,10},{3,5}â transmitted in Step 2 of the first sub-phase, respectively (by directly reading off). W{1,3,4},{1,2,10}â and W{1,3,5},{1,2,9}â can be recovered by user 6 because they are cached by user 1 and thus we can use Lemma 1.Item 2 . We also proved in (44) that W{3,4,5},{1,2,10}ââW{3,4,5},{1,2,9}â can be recovered by user 6.
Hence, user 6 can reconstruct C{1,2,9,10},{3}â and thus it can recover W{1,2,3},{3,9,10}â.
By similar steps, for each desired sub-block W{1,2,3},V2ââ where {1,2,6}âŠV2â=â
, user 6 first reconstructs CV2ââŞ{2},{1,2,3}â{2}â and then recovers W{1,2,3},V2ââ from CV2ââŞ{2},{1,2,3}â{2}â.
Hence, we prove that user 6 can recover W{1,2,3}â.
Similarly, we can prove user 6 can recover WS2ââ where {dkâ,dujââ}={1,2}âS2â.
For each sub-block WS2â,V2ââ where d6â=1âS2â, dujââ=2â/S2â, 6â/V2â, and ujâ=2âV2â, user 6 can recover WS2â,V2ââ
from CV2ââŞ{6},S2ââ{1}â by directly reading off. Hence, we finish the proof of the decodability of user 6 for j=2.
By the induction method,
other desired blocks can also be recovered by user 6 with the above decoding procedures.
Performance
The achieved load is 31/30â1.033 while the converse bound in Theorem 1 is 707/720â0.982 and the achieved load in [12] is 7/6â1.167.
V-E Proof of Theorem 4
For type sâ[min{K,N}] and each corner point M=KrNtâ where tâ[0:K], from Theorem 3, we can achieve the load
[TABLE]
where (46d) comes from the Pascalâs triangle. Hence, from (46f) and the converse bound in Theorem 1, we proved the proposed caching scheme in Theorem 3 is order optimal to within a factor of 2 under the constraint of uncoded cache placement for demand type s.
Similarly, we can prove that the average load among all possible demands in Theorem 3 is order optimal to within a factor of 2 under the constraint of uncoded cache placement.
V-F Proof of Theorem 5
From the proof of the decodability in Appendix E, we have the following observations (Observations 2 and 3 are proved in Appendix E), which will help us to further reduce the load for some special cases:
-
Observation 1: when r=2, the transmission of the second sub-phase does not exist because âŁBâ˛âŁ=râ2=0 and Bâ˛âŠN([K])î =â
can not hold simultaneously. When t=1,
the transmission of the second sub-phase does not exist because âŁJâ˛âŁ=tâ1=0 and Jâ˛âŠ{uq+1â,âŚ,uNeâ(d)â}î =â
, can not hold simultaneously.
In other words, each non-leader can recover all its desired files from the first sub-phase if r=2 or t=1.
2. 2.
Observation 2: for a non-leader k, to decode WS2â,V2ââ where dkââS2â, {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
and
{k,u1â,âŚ,ug(dkâ)â}âŠV2â=â
, if there is no user in V2â whose demanded file is in {du1ââ,âŚ,dug(dkâ)â1ââ}, user k only needs to use the transmission of the first sub-phase, Step g(dkâ) of the second sub-phase and Step g(dkâ) in Lemma 2.
3. 3.
Observation 3: for a non-leader k, to decode WS2â,V2ââ where dkââS2â, {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
,
{k,u1â,âŚ,ug(dkâ)â}âŠV2â=â
, and (âŞk1ââV2ââ{dk1ââ})âŠ(S2ââ{dkâ})=â
, user k only needs the transmission of the first sub-phase.
In the following, we will show if râ{1,2,Nâ1,N} or tâ{0,1,2,Kâ1,K} or sâ[min{K,N,4}], the transmission of the second sub-phase is not needed. Notice that the transmitted load of the first sub-phase coincides with the proposed converse bound in Theorem 1. Hence, for the above cases, the transmission of the first sub-phase is optimal under the constraint of uncoded cache placement.
When râ{1,N}, the considered problem is equivalent to the MAN caching problem, the first sub-phase is equivalent to the caching scheme in [3], which is optimal under the constraint of uncoded cache placement.
When tâ{0,K}, it is trivial to achieve the optimality by transmitting all demanded files or nothing.
When r=2 or t=1, as shown in Observation 1, each non-leader can recover its desired files from the transmission of the first sub-phase.
When t=Kâ1, there is only one step in the first sub-phase. From Lemma 1.Item 2 , it can be seen that any non-leader can recover its desired blocks from Step 1 of the first sub-phase. Hence, the second sub-phase is not necessary.
We now consider r=Nâ1 or t=2 and let each non-user k recover WS2â,V2ââ where dkââS2â, {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
and
{k,u1â,âŚ,ug(dkâ)â}âŠV2â=â
, by the transmission of the first sub-phase.
The main reason that the first sub-phase is enough for these two cases, is that Step g(dkâ) of the second sub-phase could be reconstructed by user k from the first sub-phase. Consider one message
CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â which is transmitted in the second sub-phase. Notice that Bâ˛â[N]â{du1ââ,âŚ,duqââ}. If t=2, we have âŁJâ˛âŁ=1. If r=Nâ1, we have âŁBâ˛âŁ=râ2=Nâ3. Hence, for the case r=Nâ1 or t=2, all interferences in CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â to user k whose demands Fdug(dkâ)âââ, are from one block (assuming this block is WBâ˛âŞ{i}â). Hence, the binary sum of these interferences is equal to the sum of the interferences in CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛âŞ{i}â or CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛âŞ{duqââ}â. It will be proved in Appendix F that user k can recover this sum of interferences from the first sub-phase and then it can reconstruct CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â.
Hence, from Observation 2, user k can recover WS2â,V2ââ if there is no user in V2â whose demanded file is in {du1ââ,âŚ,dug(dkâ)â1ââ}.
It will be proved in Appendix F, if there is some user in V2â whose demanded file is in {du1ââ,âŚ,dug(dkâ)â1ââ}, for the case r=Nâ1 or t=2, user k can also recover WS2â,V2ââ from the reconstruction of Step g(dkâ) of the second sub-phase.
In conclusion, for the cases where râ{1,2,Nâ1,N} or tâ{1,2,Kâ1,K}, we prove that from the first delivery sub-phase, each user can recover its desired file.
Comparing the converse bound in Theorem 1 and the achieved load (given in Section V-F), we have the optimality for Case 1 where râ{1,2,Nâ1,N}. The optimality for Case 2 where either KrM/Nâ¤2 or KrM/NâĽKâ1, is due to the fact that in the converse bound (7), ctNeâ(d)â is convex in terms of t and when tâ{0,1,2,Kâ1,K}, our proposed scheme is optimal.
Finally, we prove the optimality of Ruââ(M,s) for Case 3 where sâ[min{K,N,4}]. We consider the following two cases.
-
min{K,N}â¤4.
Theorem 5.Case 1 covers all possible values of r when 3âĽNâ1, and
Theorem 5.Case 2 covers all possible values of M when 3âĽKâ1. Hence, when min{K,N}â¤4, we can prove the optimality.
2. 2.
min{K,N}>4. In this case, s=âŁN([K])âŁâ¤4.
For each subset of files Tâ[N]âN([K]) where râ4â¤âŁTâŁ<r,
we can gather all blocks WSâ where Sâ[N], âŁSâŁ=r, SâN([K])=T. The proposed first delivery sub-phase on these blocks is equivalent to the first delivery sub-phase
for Neqâ([K])=Neqâ=s, Keqâ=K, reqâ=rââŁTâŁ, and teqâ=t. Since we proved the decodability of the proposed first delivery sub-phase for the system including up to 4 files, we can prove the blocks in this group can be recovered by the demanding users. Hence, we prove that each user can recover its desired file from the first delivery sub-phase.
As a result, we prove when sâ[min{K,N,4}], each user can recover its desired file from the first delivery sub-phase, and thus we prove the optimality for Theorem 5.Case 3.
VI Conclusions
In this paper, we studied the coded caching problem with correlated sources.
We proposed a converse bound under the constraint of uncoded cache placement and two-phase delivery scheme.
For any demand type, under the constraint of uncoded cache placement, our caching scheme is optimal to within a factor of 2. For the case where each user has a distinct request, or the case with any demand type with either râ{1,2,Nâ1,N} or KrMâ¤2N or KrMâĽ(Kâ1)N or sâ[min{K,N,4}], the second sub-phase is not necessary and thus the proposed scheme is optimal under the constraint of uncoded cache placement.
As a by-product, we also showed that the proposed scheme reduces the load of existing schemes for the caching problem with multiple requests.
Appendix A Proof of Lemma 1
For a given demand vector d, let s:=Neâ(d), jmaxâ:=min{s,Nâr+1,Kât}, and order the leader users as (u1â,âŚ,usâ).
Recall that in step jâ[jmaxâ] of delivery sub-phase 1 of the scheme in (8) we satisfy the demand of leader user ujâ as follows: for each set of users Jâ[K]â{u1â,âŚ,ujâ1â} such that âŁJâŁ=t+1 and ujââJ, and for each set of files Bâ[N]â{du1ââ,âŚ,dujââ} such that âŁBâŁ=râ1, we transmit the multicast message in (20), which we re-write as
[TABLE]
where we introduced the superscript j to indicate the leader user for whom the multicast message CJ,Bjâ has been âdesigned,â by which we mean that by construction (i.e., dujâââ/B), CJ,Bjâ in (47) contains only one sub-block desired by user ujâ (which is WBâŞ{dujââ},Jâ{ujâ}â), while all other sub-blocks in CJ,Bjâ are in its cache. Based on this observation, we introduce the following terminology:
Directly read off.
The observation made for leader user ujâ actually holds for every user kâJ such that dkâî âB (i.e., term in (47a)). Thus, we say that user k âdirectly reads offâ its desired sub-block WBâŞ{dkâ},Jâ{k}â from the multicast message CJ,Bjâ. Here we use âdirectlyâ to mean that it is enough to remove the contribution of cached sub-blocks in order to recover a desired sub-block.
Indirectly read off.
For user kâJ such that dkââB, its desired sub-blocks appear in CJ,Bjâ as the linear combination iâN(J)\BââWBâŞ{i},Jâ{k}â (i.e., term in (47b)). Evidently, in (47b), the user who desires file iî âBâŞ{dujââ} is in J and is not ujâ, thus WBâŞ{i},Jâ{k}â can be âdirectly read offâ from CJ,B\{dkâ}âŞ{i}jâ. Thus, we say that user k âindirectly reads offâ its desired sub-block WBâŞ{dujââ},Jâ{k}â from the multicast message CJ,Bjâ. Here we use âindirectlyâ to mean that it is not enough to remove the contribution of cached sub-blocks in order to recover a desired sub-block, but in addition one has to remove the contribution of sub-blocks that have been âdirectly read offâ from some other multicast messages.
Lemma 1 is proved by induction.
A-A Step 1
Lemma 1.Item 1
We focus on one set of users Jâ[K] where âŁJâŁ=t+1 and u1ââJ, and one set of files Bâ[N]â{du1ââ} where âŁBâŁ=râ1.
We will prove that from Step 1, each user in k1ââJ can recover all sub-blocks in CJ,Bâ. We consider two cases:
dk1âââ/B: in CJ,Bâ user k1â caches all sub-blocks except WBâŞ{dk1ââ},Jâ{k1â}â. Hence, user k1â can recover WBâŞ{dk1ââ},Jâ{k1â}â by directly reading off.
dk1âââB: in CJ,Bâ user k1â caches all sub-blocks except WBâŞ{i},Jâ{k1â}â, where iâN(J)âB.
If iî =du1ââ, user k1â can recover WBâŞ{i},Jâ{k1â}â from CJ,(BâŞ{i})â{dk1ââ}â by directly reading off as the similar reason described in the above case.
If i=du1ââ, since we proved that user k1â can recover all sub-blocks in CJ,Bâ except WBâŞ{du1ââ},Jâ{k1â}â, we prove user k1â can recover WBâŞ{du1ââ},Jâ{k1â}â by indirectly reading off.
In conclusion, user k1â can recover all sub-blocks in CJ,Bâ.
Hence, we proved Lemma 1.Item 1 for Step 1.
Lemma 1.Item 2
Now for each user kâ[K], if k=u1â, it can recover WS1â,V1ââ
where dkââS1â and u1ââV1â, from its cache. Hence, in the following, we will prove any user kâ([K]â{u1â}) can recover each WS1â,V1ââ
where dkââS1â, u1ââV1â and kâ/V1â, from Step 1. We consider two cases:
du1âââ/S1â. We can see that WS1â,V1ââ appears in CV1ââŞ{k},S1ââ{dkâ}â. By Lemma 1.Item 1 for Step 1, we prove that user k can recover WS1â,V1ââ.
du1âââS1â. We can see that WS1â,V1ââ appears in CV1ââŞ{k},S1ââ{du1ââ}â. By Lemma 1.Item 1 for Step 1, we prove that user k can recover WS1â,V1ââ.
Hence, we proved Lemma 1.Item 2 for Step 1.
Lemma 1.Item 3
We then focus on one user q whose demanded file is in [N]â{du1ââ}, and one sub-block WS2â,V2ââ where {dqâ,du1ââ}âS2â and {u1â,q}âŠV2â=â
.
In CV2ââŞ{u1â},S2ââ{du1ââ}â, all sub-blocks are desired by user q while only one of them is desired by user u1â (which is WS2â,V2ââ) and the others are cached by user u1â. From Lemma 1.Item 2 for Step 1, user q has recovered all desired sub-blocks which are cached by user u1â, and thus user q can recover WS2â,V2ââ from CV2ââŞ{u1â},S2ââ{du1ââ}â.
Hence, we proved Lemma 1.Item 3 for Step 1.
In summary, we proved Lemma 1 for Step 1.
A-B Step j
We focus one jâ[min{Neâ(d),Nâr+1,Kât}] and assume that Lemma 1 holds for the first jâ1 steps. In the following, we prove that Lemma 1 holds for Step j.
Lemma 1.Item 1
We focus on one set of users Jâ([K]â{u1â,âŚ,ujâ1â}) where âŁJâŁ=t+1 and ujââJ, and one set of files Bâ([N]â{du1ââ,âŚ.dujââ}) where âŁBâŁ=râ1.
We will prove that from the transmission until Step j, each user in k1ââJ can recover all sub-blocks in CJ,Bâ. We consider two cases:
dk1âââ/B. In this case, in CJ,Bâ user k1â caches all sub-blocks except WBâŞ{dk1ââ},Jâ{k1â}â. Hence, user k1â can recover WBâŞ{dk1ââ},Jâ{k1â}â by directly reading off.
dk1âââB. In this case, dk1âââ/{du1ââ,âŚ,dujââ}.
In CJ,Bâ user k1â caches all sub-blocks except WBâŞ{i},Jâ{k1â}â, where iâN(J)âB.
If iâ{du1ââ,âŚ,dujâ1ââ}, by the induction assumption, user k1â has already recovered the whole block WBâŞ{dk2ââ}â.
If iâ/{du1ââ,âŚ,dujââ},
user k1â can recover WBâŞ{dk2ââ},Jâ{k1â}â from CJ,(BâŞ{dk2ââ})â{dk1ââ}â transmitted in Step j by directly reading off.
If i=dujââ, in CJ,Bâ user k1â has cached or recovered all sub-blocks except WBâŞ{dujââ},Jâ{k1â}â. Hence, user k1â can recover WBâŞ{dujââ},Jâ{k1â}â by indirectly reading off.
In conclusion, user k1â can recover all sub-blocks in CJ,Bâ, and thus
we proved Lemma 1.Item 1 for Step j.
Lemma 1.Item 2
Now for each user kâ[K] where dkââ/{du1ââ,âŚ,dujâ1ââ}, if k=ujâ, it can recover WS1â,V1ââ
where dkââS1â and ujââV1â, from its cache.
Hence, in the following, we will prove any user kâ([K]â{ujâ}) where dkââ/{du1ââ,âŚ,dujâ1ââ}, can recover each WS1â,V1ââ
where dkââS1â, ujââV1â and {k,u1â,âŚ,ujâ1â}âŠV1â=â
, at the end of Step j.
We consider two cases:
dujâââ/S1â. We can see that WS1â,V1ââ appears in CV1ââŞ{k},S1ââ{dkâ}â transmitted in Step j. By Lemma 1.Item 1 for Step j, we prove that user k can recover WS1â,V1ââ.
dujâââS1â. We can see that WS1â,V1ââ appears in CV1ââŞ{k},S1ââ{dujââ}â transmitted in Step j. By Lemma 1.Item 1 for Step j, we prove that user k can recover WS1â,V1ââ.
Hence, we proved Lemma 1.Item 2 for Step j.
Lemma 1.Item 3
We then focus on one user q whose demanded file is in [N]â{du1ââ,âŚ,dujââ}, and one sub-block WS2â,V2ââ where {dqâ,dujââ}âS2â, {du1ââ,âŚ,dujâ1ââ}âŠS2â=â
, and {q,u1â,âŚ,ujâ}âŠV2â=â
.
In CV2ââŞ{ujâ},S2ââ{dujââ}â transmitted in Step j, all sub-blocks are desired by user q while only one of them is desired by user ujâ (which is WS2â,V2ââ) and the others are cached by user u1â. From Lemma 1.Item 2 for Step j, user q has recovered all desired sub-blocks which are cached by user ujâ, and thus user q can recover WS2â,V2ââ from CV2ââŞ{u1â},S2ââ{du1ââ}â.
Hence, we proved Lemma 1.Item 3 for Step j.
In conclusion, we proved Lemma 1.
Appendix B Proof of Lemma 2
In Step j, we focus on one Jâ˛â([K]â{u1â,âŚ,uNeâ(d)â}) where âŁJâ˛âŁ=tâ1,
and one Bâ˛â([N]â{du1ââ,âŚ,duqââ}) where âŁBâ˛âŁ=râ2 and Bâ˛âŠN([K])î =â
, and in the following we prove
CJâ˛âŞ{ujâ,uqâ},Bâ˛â can be recovered by each user k demanding Fdujâââ.
Given Jâ˛, we define a family of sets S(Jâ˛)âJⲠas follows. We divide the users JⲠinto groups, where each group is corresponding to one file in N(Jâ˛) and it contains all users in JⲠdemanding this file.
Each time, we choose one or zero user in each group which is not corresponding to the file in {dujââ,duqââ},
and replace this user by the leader who demands the file corresponding to this group. For example, Jâ˛={5,6,7,8} where dujââ=1, duqââ=2, d5â=d6â=3, d7â=4, and d8â=2. The leader user demanding F3â is user 3 while the leader user demanding F4â is user 4. We first choose user 5 in the first group and replace it by user 3, and choose user 7 in the second group and replace it by user 4. Hence, we have the set of users {3,4,6,8}âS(Jâ˛). Similarly, in this example we have
[TABLE]
For each JâS(Jâ˛), with a slight abuse of notation, we let
[TABLE]
In other words, QJâ is obtained by removing all sub-blocks from the blocks desired by user ujâ or uqâ in CJâŞ{ujâ,uqâ},Bâ˛â.
For each JâS(Jâ˛), by the definitions, we have
[TABLE]
In (49), if k3âî =ujâ, WS,JâŞ{ujâ,uqâ}â{k3â}â is cached by ujâ and from Lemma 1.Item 2 , user k can recover WS,JâŞ{ujâ,uqâ}â{k3â}â. We then focus on k3â=ujâ. Since uqââ/S, by Remark 3, it can be seen that WS,JâŞ{ujâ,uqâ}â{k3â}â can be recovered by user k. Hence, user k can reconstruct the RHS of (49).
For each J1ââS(Jâ˛) where J1âî =Jâ˛, since there exists at least one leader in J1â, it can be seen that CJâŞ{ujâ,uqâ},Bâ˛âŞ{uqâ}â and CJ1ââŞ{ujâ,uqâ},Bâ˛â
are transmitted in Step j of the first and second sub-phases, respectively. Hence, user k can reconstruct QJ1ââ from (49).
At the end of this proof, we will prove the following equation.
[TABLE]
In (50), all the messages except QJâ˛â are recovered by user k such that each user can reconstruct QJâ˛â. In addition, CJâ˛âŞ{ujâ,uqâ},Bâ˛âŞ{uqâ}â is transmitted in Step j of the first sub-phase. Hence, from (49), user k can reconstruct CJâ˛âŞ{ujâ,uqâ},Bâ˛â.
Finally, we will prove (50). We focus on one sub-block in (50) and
assume that WS,Vâ is in QJâ, which is desired by user k5â. Hence, V=JâŞ{ujâ,uqâ}â{k5â} and dk5âââ/{dujââ,duqââ}. By the construction of S(Jâ˛),
there exists only one user in Jâ˛âŞ{ug(dk5ââ)â} demanding dk5ââ, who is not in J. We assume this user is k6â. It can be seen that WS,Vâ desired by k6â, is also in QJ2ââ where J2â=JâŞ{k6â}â{k5â}. In addition, except J and J2â, there does not exist other J3ââS(Jâ˛) such that QJ3ââ contains WS,Vâ (because Vâ{dujââ,duqââ}=Jâ{k5â} can not be subset of J3â).
Hence, WS,Vâ appears twice in (50) and we prove (50).
Appendix C Proof of Lemma 3
C-A Proof of (25)
To prove (25), it is equivalent to prove that
[TABLE]
where we assume R=JâŞ{ug(i)â}. Since ug(i)ââ/J and âŁJâŁ=t+1, we have âŁRâŁ=t+2. Any CT,Hâ in (51), should satisfy TâR and âŁRâTâŁ=1. For the user in (RâT), its desired file is in H.
In addition, if CT1â,H1ââ and CT2â,H2ââ are in (51), we can see that T1âî =T2â.
We focus one sub-block WS,Vâ in (51) and assume that CT,Hâ contains WS,Vâ. It directly indicates that SâN(T)âŞH,
and that TâV, âŁTâVâŁ=1, the user in TâV (assumed to be user kâ˛) desires the sub-block WS,Vâ. In addition, since kâ˛âTâR and âŁRâTâŁ=1, assuming k1ââ(RâT), we have dk1âââH and thus WS,Vâ is also desired by user k1â.
Hence,
it can be seen that CVâŞ{k1â},Hâ{dk1ââ}âŞ{dkâ˛â}â is also in (51), and WS,Vâ desired by user k1â is in CVâŞ{k1â},Hâ{dk1ââ}âŞ{dkâ˛â}â.
Except CT,Hâ and CVâŞ{k1â},Hâ{dk1ââ}âŞ{dkâ˛â}â, there does not exist any other CT1â,H1ââ in (51) containing WS,Vâ because there is no other T1ââR where âŁT1ââŁ=âŁRâŁâ1 and VâT1â (noticing that VâR and âŁVâŁ=âŁRâŁâ2).
In conclusion, each sub-block in (51) appears twice in (51),
and thus we prove (51).
C-B Proof of (26)
To prove (26), it is equivalent to prove that
[TABLE]
If CJ1â,Hâ appears in (52), since i1ââNJ1âââŠB1â,
we have (B1ââ{i1â})âH and âŁHâ(B1ââ{i1â})âŁ=1. For the file in Hâ(B1ââ{i1â}), it is also in (NJ1âââB1â)âŞ{i1â}.
We focus one sub-block WS,Vâ in (52) and assume that CJ1â,Hâ contains WS,Vâ. It directly indicates that HâS
and âŁSâHâŁ=1 (we assume the file in SâH is iâ˛).
In addition, we have (B1ââ{i1â})âH and âŁHâ(B1ââ{i1â})âŁ=1 (we assume the file in Hâ(B1ââ{i1â}) is i2â). As described before, i2â is (NJ1âââB1â)âŞ{i1â} and thus file i2â is demanded by some user in J1â.
Hence, it can be seen that WS,Vâ is also in CJ1â,Hâ{i2â}âŞ{iâ˛}â. Except CJ1â,Hâ and CJ1â,Hâ{i2â}âŞ{iâ˛}â, there does not exist any other CJ1â,H1ââ in (52) containing WS,Vâ because there is no other H1ââS where (B1ââ{i1â})âH1â and âŁH1ââŁ=âŁSâŁâ1 (noticing that (B1ââ{i1â})âS and âŁB1ââ{i1â}âŁ=âŁSâŁâ2).
In conclusion, each sub-block in (52) appears twice in (52),
and thus we prove (52).
Appendix D Proof of Lemma 4
We use the induction method to prove Lemma 4.
j=1.
By (26) in Lemma 3 (with i1â=du1ââ), we have
[TABLE]
where each CJ2ââŞ{u1â},B2ââŞ{i2â}â is transmitted in Step 1 of the first sub-phase. Hence, each user can reconstruct CJ2ââŞ{u1â},B2ââŞ{du1ââ}â.
jâ[2:min{Neâ(d),Nâr+1,Kât}].
We first focus on CJ2ââŞ{ujâ},B2ââŞ{i}â where iâ{du1ââ,âŚ,dujâ1ââ}.
By (25) in Lemma 3, we have
[TABLE]
If dkââ{du1ââ,âŚ,dujâ1ââ}, each user can reconstruct CJ2ââŞ{ujâ,ug(i)â}â{k},B2ââŞ{dkâ}â by the induction assumption; else if dkââ/B2â, CJ2ââŞ{ujâ,ug(i)â}â{k},B2ââŞ{dkâ}â is transmitted in Step g(i) of the first sub-phase; else, we consider dkââB2â. Since N(J2ââŠL)âB2âî =â
(recall that L is the set of leaders), we can see that there exists one leader in J2ââ{k} whose demanded file is not in B2â. Thus in this case, CJ2ââŞ{ujâ,ug(i)â}â{k},B2ââŞ{dkâ}â is transmitted in Step g(i) of the second sub-phase.
We then focus on CJ2ââŞ{ujâ},B2ââŞ{dujââ}â. By (26) in Lemma 3 (with i1â=dujââ), we have
[TABLE]
In (55), if i2ââ{du1ââ,âŚ,dujâ1ââ}, we have proved CJ2ââŞ{ujâ},B2ââŞ{i2â}â can be reconstructed by each user from (54); otherwise, CJ2ââŞ{ujâ},B2ââŞ{i2â}â is transmitted in Step j of the first sub-phase.
Remark 2**.**
Notice that to prove Lemma 4 the transmission in the second sub-phase is only used when there exists some user in J2ââŞ{ujâ} whose demanded file is in B2â (i.e., dkââB2â in (54)).
Hence, if N(J2â)âŠB2â=â
, to reconstruct CJ2ââŞ{ujâ},B2ââŞ{i}â, each user only needs the transmission in the first sub-phase.
Formally,
for each jâ[min{Neâ(d),Nâr+1,Kât}] and each iâ{du1ââ,âŚ,dujââ},
any non-leader kâ[K] can reconstruct CJ2ââŞ{ujâ},B2ââŞ{i}â where J2ââ[K]â{u1â,âŚ,ujâ}, âŁJ2ââŁ=t, B2ââ([N]â{du1ââ,âŚ,dujââ}), âŁB2ââŁ=râ2, and N(J2â)âŠB2â=â
,
from the transmission of the first sub-phase.
Appendix E Proof of Decodability of the General Scheme in Section V-C
Now we are ready to prove the decodability of each non-leader k. In other words, we want to prove that it can decode WS2â,V2ââ where dkââS2â, {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
and
{k,u1â,âŚ,ug(dkâ)â}âŠV2â=â
(in Lemma 1 we showed that the other desired sub-blocks could be decoded by user k from transmission of the first sub-phase). We consider two cases, âŁS2ââŠN([K])âŁ>1 and âŁS2ââŠN([K])âŁ=1.
E-A * âŁS2ââŠN([K])âŁ>1 *
Among all desired sub-blocks in this case,
we use the induction method to prove for each jâ[g(dkâ)+1:Neâ(d)], user k can recover its desired sub-block WS2â,V2ââ where dujâââS2â or ujââV2â.
Induction on j=g(dkâ)+1.
We consider three cases:
ujââV2â and dujâââ/S2â. In CV2ââŞ{k},S2ââ{dkâ}â transmitted in Step j of the first sub-phase, user k caches all sub-blocks except WS2â,V2ââ and thus it can recover WS2â,V2ââ by directly reading off.
ujââV2â and dujâââS2â.
Since ujââV2â, from Lemma 4 it can be seen that user k can reconstruct CV2ââŞ{ug(dkâ)â},S2ââ{dujââ}â.
In CV2ââŞ{ug(dkâ)â},S2ââ{dujââ}â, all sub-blocks are desired by user k. In addition, all sub-blocks desired by user k which are cached by user ug(dkâ)â, can be recovered by user k from Lemma 1.2.
The sub-blocks in CV2ââŞ{ug(dkâ)â},Sâ{dujââ}â which are not cached by user ug(dkâ)â, are all cached by user ujâ (because ujââV2â).
For any file iâN(V2â)â(S2ââ{dujââ}), the sub-block WS2ââ{dujââ}âŞ{i},V2ââ is in CV2ââŞ{ug(dkâ)â},S2ââ{dujââ}â which is desired (and not cached) by user ug(dkâ)â.
If iî =dujââ,
since dujâââ/(S2ââ{dujââ}âŞ{i}) and ujââV2â, we proved in the first case that WS2ââ{dujââ}âŞ{i},V2ââ can be recovered by user k; otherwise, the sub-block WS2ââ{dujââ}âŞ{i},V2ââ is WS2â,V2ââ.
Hence, in CV2ââŞ{ug(dkâ)â},S2ââ{dujââ}â, only sub-block WS2â,V2ââ is not recovered by user k, such that user k can recover WS2â,V2ââ.
ujââ/V2â and dujâââS2â. We first prove that user k can reconstruct CV2ââŞ{ujâ},S2ââ{dujââ}â. From (25) in Lemma 3, we have
[TABLE]
For each k2ââ(V2ââŞ{ujâ}) in (56),
if k2â=ujâ, we have
[TABLE]
which is transmitted in Step g(dkâ) of the first sub-phase;
if k2âî =ujâ and dk2âââ/{du1ââ,âŚ,dug(dkâ)ââ},
it can be seen that CV2ââŞ{ujâ,ug(dkâ)â}â{k2â},(S2ââ{dujââ,dkâ})âŞ{dk2ââ}â is transmitted either in Step g(dkâ) of the first sub-phase (if âŁ(S2ââ{dujââ,dkâ})âŞ{dk2ââ}âŁ=râ1) or Step g(dkâ) of the second sub-phase (if âŁ(S2ââ{dujââ,dkâ})âŞ{dk2ââ}âŁ=râ2 and (V2ââ{k2â})âŠN([K])î =â
) or Step g(dkâ) in Lemma 2 (if âŁ(S2ââ{dujââ,dkâ})âŞ{dk2ââ}âŁ=râ2 and (V2ââ{k2â})âŠN([K])=â
);
if k2âî =ujâ and dk2âââ{du1ââ,âŚ,dug(dkâ)ââ},
by Lemma 4, CV2ââŞ{ujâ,ug(dkâ)â}â{k2â},(S2ââ{dujââ,dkâ})âŞ{dk2ââ}â can be reconstructed by user k.
Hence, user k can recover each message on the RHS of (56) and thus it can reconstruct CV2ââŞ{ujâ},S2ââ{dujââ}â.
In CV2ââŞ{ujâ},S2ââ{dujââ}â, all sub-blocks are desired by user k.
For each kâ˛â(V2ââŞ{ujâ}), if kâ˛î =ujâ, the desired sub-blocks in CV2ââŞ{ujâ},S2ââ{dujââ}â by user kⲠare stored by user ujâ, which can be recovered by user k from the transmission of the first sub-phase (as we proved above for the case ujââV2â and dujâââ/S2â). If kâ˛=ujâ, the desired sub-block by user kⲠis WS2â,V2ââ. Hence, user k can recover WS2â,V2ââ.
Induction on jâ[g(dkâ)+1:Neâ(d)]. If there exists jâ˛â[g(dkâ)+1:jâ1], where ujâ˛ââV2â or dujâ˛âââS2â, by the induction assumption, user k can recover WS2â,V2ââ; otherwise, we can use the similar proof by dividing into three cases and using the induction assumption, to prove user k can recover WS2â,V2ââ (for the sake of simplicity, we do not repeat).
Remark 3**.**
If there exists one leader in V2â (assumed to be kâ˛) such that dkâ˛ââ/S2â, we can prove user k can recover WS2â,V2ââ without using Lemma 2. More precisely, we focus on the case ujââV2â and dujâââS2â, where Lemma 2 may be needed.
In (56), for each k2ââV2â where dk2âââ/{du1ââ,âŚ,dug(dkâ)ââ}, if k2âî =kâ˛, it can be seen that (V2ââ{k2â})âŠN([K])î =â
and thus Lemma 2 is not needed; otherwise, we have k2â=kⲠand âŁ(S2ââ{dujââ,dkâ})âŞ{dkâ˛â}âŁ=râ1 such that Lemma 2 is not needed.
E-B âŁS2ââŠN([K])âŁ=1
We can gather all blocks WSâ where SâŠ([N]âN([K]))=S2ââŠ([N]âN([K])). The transmission for these blocks is equivalent to the MAN caching problem in [1] and thus from the transmission of the first sub-phase on these blocks which is equivalent to the optimal caching scheme in [3],
each non leader can recover WS2â,V2ââ.
E-C Proof of Observations
If âŁS2ââŠN([K])âŁ=1, it has been proved that only the first sub-phase is needed. Hence, in the following we consider âŁS2ââŠN([K])âŁ>1.
We focus on each non-leader k and the induction Step jâ[g(dkâ)+1:Neâ(d)] in the proof of the decodability in Appendix E-A.
Proof of Observation 1
The proof of Observation 1 is trivial and directly given in Section V-F.
Proof of Observation 2
Other steps of the second sub-phase may be needed only when we use Lemma 4 to show that user k can reconstruct
[TABLE]
where dk2ââ=dkâ.
However, in induction Step g(dkâ) of the proof of Lemma 4 with i=dkâ, the first sub-phase and Step g(dkâ) of the second sub-phase are only needed if there is no user in V2â whose demanded file is in {du1ââ,âŚ,dug(dkâ)â1ââ}.
Hence, we prove Observation 2.
Proof of Observation 3
If ujââV2â and dujâââ/S2â, from the proof in Appendix E-A, the first sub-phase is only needed;
if ujââV2â and dujâââS2â, user k needs to reconstruct CV2ââŞ{ug(dkâ)â},S2ââ{dujââ}â. Since (âŞk1ââV2ââ{dk1ââ})âŠ(S2ââ{dkâ})=â
, from Remark 2 we can see that CV2ââŞ{ug(dkâ)â},S2ââ{dujââ}â can be reconstructed by user k from the transmission of the first sub-phase;
Lastly we focus on ujââ/V2â and dujâââS2â. In (56),
if k2â=ujâ, the first sub-phase is only needed;
if k2âî =ujâ and dk2âââ/{du1ââ,âŚ,dug(dkâ)ââ}, since (âŞk1ââV2ââ{dk1ââ})âŠ(S2ââ{dkâ})=â
, we have âŁ(S2ââ{dujââ,dkâ})âŞ{dk2ââ}âŁ=râ1 and thus we only need the first sub-phase;
if k2âî =ujâ and dk2âââ{du1ââ,âŚ,dug(dkâ)ââ}, user k should reconstruct CV2ââŞ{ujâ,ug(dkâ)â}â{k2â},(S2ââ{dujââ,dkâ})âŞ{dk2ââ}â. Again, since (âŞk1ââV2ââ{dk1ââ})âŠ(S2ââ{dkâ})=â
, from Remark 2 we can see that user k can reconstruct CV2ââŞ{ujâ,ug(dkâ)â}â{k2â},(S2ââ{dujââ,dkâ})âŞ{dk2ââ}â from the first sub-phase.
Hence, we prove Observation 3.
Appendix F Proof of the Decodability for r=Nâ1 or t=2
We now consider r=Nâ1 or t=2 and prove that each non-user k can recover WS2â,V2ââ where dkââS2â, {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
and
{k,u1â,âŚ,ug(dkâ)â}âŠV2â=â
, by the transmission of the first sub-phase.
If N(V2â)âŠ(S2ââ{dkâ})=â
, by Observation 3, user k can recover WS2â,V2ââ from the first sub-phase. Hence, in the following, we focus on N(V2â)âŠ(S2ââ{dkâ})î =â
.
We consider two cases, N(V2â)âŠ{du1ââ,âŚ,dug(dkâ)â1ââ}=â
and N(V2â)âŠ{du1ââ,âŚ,dug(dkâ)â1ââ}î =â
.
F-A * N(V2â)âŠ{du1ââ,âŚ,dug(dkâ)â1ââ}=â
*
In the following, we prove that for each integer qâ[g(dkâ)+1:min{Nâr+2,Kât+1,Neâ(d)}],
user k can reconstruct CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â from the first sub-phase, where Jâ˛â([K]â{u1â,âŚ,uqâ}), âŁJâ˛âŁ=tâ1, Bâ˛â([N]â{du1ââ,âŚ,duqââ}), âŁBâ˛âŁ=râ2, and Bâ˛âŠN([K])î =â
.
If there is no user in JⲠwhose demand is in [N]â({dkâ,duqââ}âŞBâ˛), it can be seen that all sub-blocks in CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â are from WBâ˛âŞ{dkâ,duqââ}â. Hence, we have CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â=CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛âŞ{duqââ}â, which is transmitted in Step g(dkâ) of the first sub-phase. Hence, in the following, we consider that there exists some user in JⲠwhose demand is in [N]â({dkâ,duqââ}âŞBâ˛).
For the case t=2, we have âŁJâ˛âŁ=1 and we assume user kⲠis in Jâ˛. For the case r=Nâ1, we have âŁBâ˛âŁ=râ2=Nâ3.
Hence, when r=Nâ1 or t=2, all interferences in CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â to user k whose demands Fdug(dkâ)âââ, are from one block (assuming this block is WBâ˛âŞ{i}â, where i=dkâ˛â for t=2, and i=[N]â(Bâ˛âŞ{dkâ,duqââ}), with a slight abuse of notation). The sum of the interferences in CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â is
[TABLE]
if iâ/{du1ââ,âŚ,duqâ1ââ}, we can see that
[TABLE]
In (58), CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛âŞ{duqââ}â is transmitted in Step g(dkâ) of the first sub-phase.
If k3âî =ug(dkâ)â, the sub-block WBâ˛âŞ{dkâ,i},Jâ˛âŞ{ug(dkâ)â,uqâ}â{k3â}â is desired by user k and cached by user ug(dkâ)â. Thus by Lemma 1.Item 2 , user k can recover this sub-block from the transmission of the first sub-phase;
if k3â=ug(dkâ)â, WBâ˛âŞ{dkâ,i},Jâ˛âŞ{uqâ}â can be recovered by user k from CJâ˛âŞ{ug(dkâ)â,uqâ,k}â{k3â},Bâ˛âŞ{i}â transmitted in Step q of the first sub-phase, where in CJâ˛âŞ{uqâ,k},Bâ˛âŞ{i}â user k caches all except WBâ˛âŞ{dkâ,i},Jâ˛âŞ{uqâ}â such that it can recover this sub-block.
Hence, user k can reconstruct CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â from the transmission of the first sub-phase;
if iâ{du1ââ,âŚ,dug(dkâ)â1ââ}, by Lemma 1.Item 3 , we can see that each sub-block WBâ˛âŞ{dkâ,i},Jâ˛âŞ{ug(dkâ)â,uqâ}â{k3â}â in (58) is from WBâ˛âŞ{dkâ,i}â, which can be recovered by user k from the first sub-phase. Hence, user k can reconstruct CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â from the transmission of the first sub-phase;
if iâ{dg(dkâ)+1â,âŚ,duqââ}, for each user k4ââJâ˛âŞ{uqâ} where dk4ââî =dkâ, we focus on CJâ˛âŞ{ug(dkâ)â,uqâ,ug(i)â}â{k4â},Bâ˛âŞ{duqââ}â which is transmitted in Step g(dkâ) of the first sub-phase. In CJâ˛âŞ{ug(dkâ)â,uqâ,ug(i)â}â{k4â},Bâ˛âŞ{duqââ}â, since we have âŁJâ˛âŁ=1 or âŁBâ˛âŁ=Nâ3, it can be seen that all sub-blocks are from either WBâ˛âŞ{duqââ,dkâ}â or WBâ˛âŞ{duqââ,i}â, and cached by either cached by user ug(dkâ)â or by user ug(i)â.
By Lemma 1.Item 2 , user k can recover the desired sub-block cached by user ug(dkâ)â from the first sub-phase.
Each sub-block of WBâ˛âŞ{duqââ,dkâ}â cached by user ug(i)â and not by ug(dkâ)â (assumed to be WBâ˛âŞ{duqââ,dkâ},Vâ˛â ), can be recovered by user k from CVâ˛âŞ{k},Bâ˛âŞ{duqââ}â (transmitted in Step g(i) of the first sub-phase), because all sub-blocks in CVâ˛âŞ{k},Bâ˛âŞ{duqââ}â except WBâ˛âŞ{duqââ,dkâ},Vâ˛â are cached by user k. Hence, in CJâ˛âŞ{ug(dkâ)â,uqâ,ug(i)â}â{k4â},Bâ˛âŞ{duqââ}â, user k can recover all sub-blocks of WBâ˛âŞ{duqââ,dkâ}â.
So user k can recover the sum of the sub-blocks of WBâ˛âŞ{duqââ,i}â in CJâ˛âŞ{ug(dkâ)â,uqâ,ug(i)â}â{k4â},Bâ˛âŞ{duqââ}â from the transmission of the first sub-phase,
[TABLE]
By the similar proof as (51) and (52), we can prove that
[TABLE]
from the fact that each sub-block in (60) appears twice in (60). Hence, user k can recover I from the transmission of the first sub-phase. In addition, by the definition, we have
[TABLE]
where CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛âŞ{i}â and CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛âŞ{duqââ}â are transmitted in Step g(dkâ) of the first sub-phase. Hence, user k can reconstruct CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â from the transmission of the first sub-phase.
In conclusion, we prove that from the transmission of the first sub-phase, user k can reconstruct CJâ˛âŞ{ug(dkâ)â,uqâ},Bâ˛â, for each integer qâ[g(dkâ)+1:min{Nâr+2,Kât+1,Neâ(d)}],
each Jâ˛â([K]â{u1â,âŚ,uqâ}) where âŁJâ˛âŁ=tâ1, and each Bâ˛â([N]â{du1ââ,âŚ,duqââ}), where âŁBâ˛âŁ=râ2 and Bâ˛âŠN([K])î =â
.
Hence, from Observation 2, user k can recover WS2â,V2ââ where N(V2â)âŠ{du1ââ,âŚ,dug(dkâ)â1ââ}=â
, from the transmission of the first sub-phase.
F-B * N(V2â)âŠ{du1ââ,âŚ,dug(dkâ)â1ââ}î =â
*
For the case t=2, since N(V2â)âŠ(S2ââ{dkâ})î =â
and N(V2â)âŠ{du1ââ,âŚ,dug(dkâ)â1ââ}î =â
where {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
and âŁV2ââŁ=2, it can be seen that âŁN(V2â)âS2ââŁ=1 and dkââ/(N(V2â)âS2â). For the case r=Nâ1, since N(V2â)âŠ{du1ââ,âŚ,dug(dkâ)â1ââ}î =â
where {du1ââ,âŚ,dug(dkâ)â1ââ}âŠS2â=â
and âŁS2ââŁ=r=Nâ1, it can also be seen that âŁN(V2â)âS2ââŁ=1 and dkââ/(N(V2â)âS2â).
Hence, when t=2 or r=Nâ1,
the interferences in CV2ââŞ{ug(dkâ)â},S2ââ{dkâ}â (transmitted in Step g(dkâ) of the first sub-phase) to user k are all from the block WS2ââŞ{i}â{dkâ}â, where i is the element in N(V2â)âS2â. The sum of the interferences in CV2ââŞ{ug(dkâ)â},S2ââ{dkâ}â is
[TABLE]
For each user k4ââV2â where dk4ââî =dkâ, we focus on CV2ââ{k4â}âŞ{ug(dkâ)â,ug(i)â},S2ââ{dkâ}â which is transmitted in Step i of the first sub-phase. In CV2ââ{k4â}âŞ{ug(dkâ)â,ug(i)â},S2ââ{dkâ}â, since âŁV2ââŁ=2 or âŁS2ââŁ=Nâ1, it can be seen that
all sub-blocks are from either WS2ââ or WS2ââ{dkâ}âŞ{i}â. Each sub-block from WS2ââ is either cached by user ug(dkâ)â or by user ug(i)â, which can be recovered by user k from the first sub-phase, by Lemma 1.Item 2 . Hence, user k can recover the sum of the sub-blocks of WS2ââ{dkâ}âŞ{i}â in CV2ââ{k4â}âŞ{ug(dkâ)â,ug(i)â},S2ââ{dkâ}â as follows,
[TABLE]
By the similar proof as (51) and (52), we can prove that
[TABLE]
from the fact that each sub-block in (64) appears twice in (64). Hence, user k can reconstruct the sum of all interferences IⲠin CV2ââŞ{ug(dkâ)â},S2ââ{dkâ}â. Other sub-blocks in CV2ââŞ{ug(dkâ)â},S2ââ{dkâ}â are from the block WS2ââ which is desired by user k. In addition, all these sub-blocks are cached by user ug(dkâ)â except WS2â,V2ââ. By Lemma 1.Item 2 , from the transmission of first sub-phase user k
can recover the sub-blocks of WS2ââ which are cached by user ug(dkâ)â. Hence, user k can also recover WS2â,V2ââ in the first sub-phase.
Appendix G Codes for Extension to Caching with Multiple Requests
For the caching problem with multiple requests considered in [17] where each user demands L uncorrelated and equal-length files, the proposed delivery scheme in [17] was proved to be optimal under the constraint of the MAN placement for most demands with Kâ¤4, M=N/K, and L=2, except one demand for K=3 and three demands for K=4.
Different from the considered problem in this paper, the demands are not generally symmetric for the caching problem with multiple requests. Hence, for the caching problem with multiple requests, we pick a set of leaders such that each leader has at least one specific demanded file which is not demanded by other leaders, and the union set of demanded files by the leaders should be equal to the union set of demanded files by all users. In addition, the number of leaders should be as small as possible. We can then extend the proposed scheme for t=1 in order to achieve the optimality for those four exceptional demands, by satisfying the demands of leaders subsequently and aligning the interferences to non-leaders simultaneously.
-
d1â={F1â,F2â}, d2â={F1â,F3â}, and d3â={F2â,F3â} (case D7â in [17]). We use the MAN placement and divide each file Fiâ where iâ[N] into (tKâ) non-overlapping and equal-length subfiles, Fiâ={Fi,Wâ:Wâ[K],âŁWâŁ=t}, where t=KM/N=1. It can be seen this case is equivalent to our considered (N,K,M,r)=(3,3,1,2) shared-link caching problem with correlated files. Hence, we can directly use the proposed delivery phase in this paper to transmit the linear combinations (with leader permutation (1,2))
[TABLE]
Hence, the load is 5/3 which coincides with the converse bound under the constraint of MAN placement in [17], while the proposed caching scheme in [17] achieves 2.
2. 2.
d1â={F1â,F2â}, d2â={F1â,F3â}, d3â={F2â,F3â}, and d4â={F4â,F5â} (case D15â˛â in [17]). It can be seen that
if we only focus on the demands of users 1,2,3, it is equivalent to our considered (N,K,M,r)=(3,3,1,2) shared-link caching problem with correlated files. In addition, the demanded file by user 4 are independent to any demanded file by users 1,2,3.
Hence, we first satisfy the demands of user 4 and then use the codes for our considered (N,K,M,r)=(3,3,1,2) shared-link caching problem with correlated files. Thus we transmit (with leader permutation (4,1,2))
[TABLE]
Hence, the load is 11/4 which coincides with the converse bound under the constraint of MAN placement in [17], while the proposed caching scheme in [17] achieves 3.
3. 3.
d1â={F1â,F2â}, d2â={F1â,F3â}, d3â={F1â,F4â}, and d4â={F2â,F3â} (case D17â˛â in [17]).
We choose the leader set as {3,4} and the chose permutation is (3,4). Inspired from proposed scheme for t=1, the delivery contains two steps where in the first and second steps, we satisfy the demands of users 3 and 4, respectively.
In Step 1, we first let user 3 recover F1â. For each user kâ{1,2,4}, if F1â is demanded by user k, we transmit F1,{k}ââF1,{3}â; otherwise, we pick one demanded file by user k which is not F4â (assumed to be Fiâ), and transmit F1,{k}ââFi,{3}â.
We then let user 3 recover F4â. For each user kâ{1,2,4}, if F4â is demanded by user k, we transmit F4,{k}ââF4,{3}â; otherwise, we pick one demanded file by user k which is not Fiâ nor F1â (assumed to be Fiâ˛â), and transmit F4,{k}ââFiâ˛,{3}â.
By this way, we transmit in the the steps (with leader permutation (3,4))
[TABLE]
Hence, the load is 10/4 which coincides with the converse bound under the constraint of MAN placement in [17], while the proposed caching scheme in [17] achieves 11/4.
4. 4.
d1â={F1â,F2â}, d2â={F1â,F2â}, d3â={F1â,F3â}, and d4â={F2â,F3â} (case D20â˛â in [17]).
It can be seen this case is equivalent to our considered (N,K,M,r)=(3,4,1,2) shared-link caching problem with correlated files. Hence, we can directly use the proposed delivery phase in this paper to transmit the linear combinations (with leader permutation (1,3))
[TABLE]
Hence, the load is 2, which coincides with the converse bound under the constraint of MAN placement in [17], while the proposed caching scheme in [17] achieves 9/4.