Skip to main content
Entropy logoLink to Entropy
. 2024 Mar 12;26(3):250. doi: 10.3390/e26030250

Fundamental Limits of Coded Caching in Request-Robust D2D Communication Networks

Wuqu Wang 1, Zhe Tao 2, Nan Liu 1,*, Wei Kang 3
Editors: Shenghao Yang, Kenneth Shum
PMCID: PMC10969329  PMID: 38539761

Abstract

D2D coded caching, originally introduced by Ji, Caire, and Molisch, significantly improves communication efficiency by applying the multi-cast technology proposed by Maddah-Ali and Niesen to the D2D network. Most prior works on D2D coded caching are based on the assumption that all users will request content at the beginning of the delivery phase. However, in practice, this is often not the case. Motivated by this consideration, this paper formulates a new problem called request-robust D2D coded caching. The considered problem includes K users and a content server with access to N files. Only r users, known as requesters, request a file each at the beginning of the delivery phase. The objective is to minimize the average and worst-case delivery rate, i.e., the average and worst-case number of broadcast bits from all users among all possible demands. For this novel D2D coded caching problem, we propose a scheme based on uncoded cache placement and exploiting common demands and one-shot delivery. We also propose information-theoretic converse results under the assumption of uncoded cache placement. Furthermore, we adapt the scheme proposed by Yapar et al. for uncoded cache placement and one-shot delivery to the request-robust D2D coded caching problem and prove that the performance of the adapted scheme is order optimal within a factor of two under uncoded cache placement and within a factor of four in general. Finally, through numerical evaluations, we show that the proposed scheme outperforms known D2D coded caching schemes applied to the request-robust scenario for most cache size ranges.

Keywords: coded caching, device-to-device, request-robust, order-optimal scheme

1. Introduction

In recent years, the demand for user throughput has greatly increased by applications based on fifth-generation (5G) mobile networks [1], such as short videos, self-driving vehicles, the Metaverse, etc. Fortunately, the data of such applications can be pre-stored in the user’s storage during low-network consumption periods, preventing network congestion during peak hours. This approach is known as caching [2]. There are typically two phases in the caching process [3]. Before knowing any user requests, the server fills the users’ caches in the placement phase during off-peak hours. The delivery phase follows in peak hours. The delivery signals will be designed and transmitted from terminals like the server or the users to satisfy all user demands when they are revealed. Technology for caching has advanced quickly in recent years, and it is currently regarded as one of the effective methods for relieving the congestion of wireless networks.

Traditional caching ignores the processing capability of the users, and therefore, the contents cached by the users and the signals transmitted by the server are both uncoded. In contrast to traditional caching, coded caching [3], proposed by Maddah-Ali and Niesen, uses a combination of coded multi-casting and device caching to simultaneously fulfill multiple requests through coded transmissions. The coded caching strategy works for the prototypical network topology called the single shared-link network, e.g., vehicular networks [4]. Both the cache contents of the users and the delivery signal from the server are allowed to be coded in the coded caching problem. The aim is to design a caching and delivery scheme that minimizes the average and worst-case delivery rate, which is defined as the average and worst-case number of broadcast bits among all possible user requests. When the optimal caching and delivery scheme that achieves the lowest worst-case delivery rate can be found for any user cache size, the optimal tradeoff between rate and memory for the system is determined. If each user directly stores a subset of the files’ bits in its cache without coding, it is referred to as an uncoded cache placement scheme; otherwise, it is referred to as a coded cache placement scheme. The original problem [3] studied in coded caching is centralized, assuming that all users present during the placement phase will each make a request for a file at the beginning of the delivery phase. Decentralized coded caching [5,6,7] also considers the possibility of users leaving or turning off during the delivery phase and explores less coordinated caching strategies.

Taking self-driving vehicles as an example: one promising approach to improve the communication efficiency is through the use of device-to-device (D2D) communication, which allows the users to directly exchange information with each other without the need for a server like a base station. This can be particularly useful in situations where the traditional infrastructure is limited or unavailable, such as in remote or rural areas. To solve the coded caching problem in these scenarios, a framework is proposed by Ji et al. in [8] for D2D coded caching. In the placement phase, similar to coded caching [3], the server fills the users’ caches before the users make any requests. In the delivery phase, when the users reveal their demands, the server is disconnected from the users and it is up to the users to communicate with each other so that each user can decode the file it requested using the signals transmitted by the other users and the contents of its local cache. For the centralized D2D coded caching problem, the caching strategy of [3] (Algorithm 1), which is uncoded, is widely used in the placement phase, e.g., in [8,9] and so on. In [8], a novel delivery scheme was provided that is appropriate for the D2D scenario. Additionally, a well-known D2D coded caching converse was proposed in [8], and it has been demonstrated that, when the memory size is large, the proposed D2D caching and delivery scheme is order optimal within a constant factor. It is difficult to find the optimal caching and delivery scheme and the corresponding optimal rate–memory tradeoff for the centralized D2D coded caching problem. However, there are many researchers who try to find the fundamental limits of the centralized D2D coded caching problems under certain assumptions or additional constraints, e.g., [9,10].

With concern to the timeliness of the communication, one-shot delivery, which is defined to satisfy the condition that each user can decode any bit of its requested file from its own cache and the transmitted signal from at most one other user, is proposed in [9] for the centralized D2D coded caching problem. For example, one self-driving vehicle may quickly decode the requested map data after receiving the signals transmitted by another self-driving vehicle, without waiting for all the considered vehicles to complete the transmission of signals. The proposed caching and delivery scheme in [9] is optimal under the constraint of uncoded cache placement and one-shot delivery, and it is order optimal within a factor of two if the converse of the shared-link coded caching problem with uncoded cache placement [11] is used as the lower bound and order optimal within a factor of four compared to the general D2D coded caching converse results.

In addition to [9], many other researchers study variants of the D2D coded caching problems, such as allowing for coded placement with three users [10], private caching [12], private caching with a trusted server [13,14], distinct cache sizes [15], finite file packetizations [16], finite-length analysis [17], secure coded caching [18], secure delivery [19], wireless multi-hop D2D networks [20,21], partially cooperative D2D communication networks [22,23], constructions of placement delivery arrays (PDAs) [24], and so on. Among these papers, most of them assume that all users will request content at the beginning of the delivery phase. However, in practice, this may not be true. For example, when assisted self-driving vehicles within a certain range carry out D2D communication, they may not request at the same time or some of them may be driven manually and do not need to access high-definition map data. In these situations, waiting for all users to request content will waste time, and setting the requests of the users who do not request some arbitrary file demand will waste communication resources. Note that in these scenarios, even though the users may not request data, they are still available to participate in the delivery phase by transmitting signals that are functions of their cached contents.

Hence, in this paper, we propose and study a new problem called request-robust D2D coded caching, where in the delivery phase, though all users in the placement phase are still present and may help with the transmission, some of them do not request any files. It is not known in the placement phase the number or identity of the users who do not request files. This problem is not the same as the decentralized D2D coded caching problem [8], where users who leave or turn off during the delivery phase do not make file requests, nor do they participate in the delivery. Note that this problem is similar to the user inactivity problem in the D2D caching setting [9,22], where each user may independently have a probability of being inactive, i.e., they do not make a file request at the beginning of the delivery phase. However, in the request-robust D2D coded caching problem, inactive users still help in the delivery phase by transmitting signals, whereas in the user inactivity problem, they do not.

1.1. Main Contributions

The main contributions of the paper can be summarized as follows:

  • (1)

    For the request-robust D2D coded caching problem, we adapt the scheme from [9] for uncoded cache placement and one-shot delivery and call the adapted scheme the adapted Yapar–Wan–Schaefer–Caire (YWSC) scheme.

  • (2)

    In order to find better performance, we present a new achievable scheme based on the uncoded cache placement and exploiting common demands [11] and one-shot delivery [9]. The caching strategy is the same as that proposed by Maddah-Ali and Niesen in [3] (Algorithm 1), while the delivery strategy divides the sub-files into three categories, and different delivery signals are designed for each category. We call the new scheme the three-category-based scheme. This scheme was presented in the conference version of this paper [25].

  • (3)

    We propose an information-theoretic lower bound under uncoded cache placement based on seeking the converse of a problem called coded caching with inactive users. The problem of coded caching with inactive users was proposed in [26], where users are inactive with a certain probability in the traditional coded caching problem of [3]. Hence, the converse for the problem of coded caching with inactive users can serve as a converse for the request-robust D2D coded caching problem. Note that [26] only considers the optimization of the cache replication parameter and does not provide a converse for the caching and delivery scheme.

  • (4)

    We prove that the performance of the adapted YWSC scheme is order optimal within a factor of two under the assumption of uncoded cache placement and within a factor of four in general.

  • (5)

    Through numerical evaluation, we show that the three-category-based scheme outperforms the adapted YWSC scheme, as well as other known D2D coded caching schemes [3] applied to the request-robust scenario.

1.2. Notations

Throughout this paper, H(·) represents the entropy of random variables, |·| represents the cardinality of a set, ⊕ denotes finite field addition, we let X\Y=xX|xY, [x:y:z]=x,x+y,x+2y,...,z, [x:y]=[x:1:y] and [n]=[1:n]. For two integers x, and y, if x<y or x0, we let yx=0.

2. System Model and Related Background

2.1. System Model

We study the request-robust D2D coded caching problem, which is defined in the following. We consider a D2D coded caching system (see Figure 1) where a server is connected to a fixed content file database of N files, W=(W1,,WN). Each file consists of F bits. There are K users in the system, each with a cache of size MF bits. We focus on the non-trivial scenario where MN. Let K be the set of user indices, i.e., K=[K].

Figure 1.

Figure 1

System model for request-robust D2D coded caching problem when there are 3 users. In this realization, User 2 does not request. Solid and dotted lines indicate placement and delivery phases, respectively.

The system operates in two phases. In the placement phase, each user’s cache is filled by the central server, which does not know the number of users or the identities of the users requesting files in the other phase. Denote the content in the cache of User k as Zk, kK. In the delivery phase, some of the K users will make file requests while others will not. We denote the set of users making file requests as R, RK. Each user in R will request a single file. Let r denote the number of users requesting files, i.e., r|R|, and we assume that the file requests, i.e., which user requests which file and which users are not requesting any files, are known to all K users. Each of the K users will send a signal that will be received by the users in R. It is required that each user in R can decode its requested file by using the signals received and its own cache content. Note that Figure 1 is different from [9] (Figure 1), i.e., there exists a user who does not request any file in Figure 1, while in [9] (Figure 1), all users request files.

More specifically, a caching and delivery scheme for this system consists of

  • 1.
    K caching functions
    φk:[2F]N[2MF],kK,
    which map the N files into cache contents of the users, denoted by Zk=φk(W1,,WN),kK. Thus, we have the following entropy constraint:
    H(Zk|W1,W2,,WN)=0,kK.
  • 2.
    Kr=1KKrNr encoding functions
    ϕkDR:[2MF][2RkF],kK.
    where DR is the set of file requests made by the users in R. For example, if there are K=4 users, and Users 1 and 3 do not request files during the delivery phase, the request vector is D{2,4}=(d2,d4). The encoding function ϕkDR denotes the mapping of User k from its cached content to the signal it transmits, which is denoted as XkDR, i.e., XkDR=ϕkDR(Zk). Thus, we have
    H(XkDR|Zk)=0,kK. (1)

    We assume the signal XkDR consists of RkDRF bits. The signals transmitted by all K users consist of RDRF bits, i.e., RDR=k=1KRkDR.

  • 3.
    r=1KKrrNr decoding functions
    ψkDR:[2MF]×[2FuK{k}RuDR][2F],kR,
    which is the decoding function used by User k. For example, if there are K=4 users, and Users 1 and 3 do not request any file during the delivery phase, the decoded files at Users 2 and 4 are W^d2=ψ2(d2,d4)(Z2,X1(d2,d4),X3(d2,d4),X4(d2,d4)) and W^d4=ψ4(d2,d4)(Z4,X1(d2,d4),X2(d2,d4),X3(d2,d4)), respectively.

Correct decoding by the users requesting files is given by W^dk=Wdk,kR, or in other words,

H(Wdk|Zk,X[K]{k}DR)=0,kR, (2)

which is called the decodability constraint. We find that by combing (1) and (2), one can decode any file by knowing the cache of all users, i.e.,

H(W[N]|Z[K])=0. (3)

which implies that we are interested in the case where KMN.

For any caching and delivery scheme that satisfies the decodability constraint, for a fixed R with size r, we define DR as the set of all possible demands {1,,N}r. We are interested in two performance metrics: one is with respect to the average performance, and the other is with respect to the worst performance. More specifically, the average performance is defined as follows: we assume that the request vector DR is uniformly distributed on DR. Then, the average delivery rate with respect to the uniform demand Rave,req-robR is defined as

Rave,req-robR=EDR[RDR].

For a given r, we define the maximum average delivery rate with respect to the uniform demand Rave,req-robr, where the maximum is over all request sets R with size r, i.e.,

Rave,req-robr=maxR:|R|=rRave,req-robR

The worst-case performance is defined as follows: first, the worst-case delivery rate Rworst,req-robR is defined as

Rworst,req-robR=maxDRRDR.

For a given r, we define the maximum worst-case delivery rate Rworst,req-robr, where the maximum is over all request sets R with size r, i.e.,

Rworst,req-robr=maxR:|R|=rRworst,req-robR.

We would like to design caching and delivery schemes such that Rave,req-robr and Rworst,req-robr are both the smallest for every r=1,2,,K. As can be seen, this is a multi-objective optimization.

For easy presentability of the results, following the notation of [11], we denote Ne(DR) as the number of distinct files in a request vector DR. DR{k} and Ne(DR{k}) are denoted as the request vector of users R{k} and the number of distinct files requested by all requesters but User k, respectively.

2.2. Preliminaries

In this subsection, we briefly summarize the related approaches, namely the uncoded symmetric placement scheme in [3] and the problem of coded caching with inactive users, which are critical for building our results for the request-robust D2D coded caching problem.

2.2.1. Uncoded Symmetric Placement Scheme

First, we introduce the uncoded symmetric placement scheme, which is useful for our scheme proposed in Section 4.

Definition 1.

(Maddah-Ali Niesen [MAN] Uncoded Symmetric Placement Scheme): Define t as t=KM/N. When t is an integer, we have the MAN uncoded symmetric placement scheme as follows: Each file Wn is divided into Kt disjoint sub-files denoted by Wn,T, where n[N], TK, |T|=t, and H(Wn,T)=F/Kt. Each user k caches all the bits of the sub-files Wn,T, n[N], for all Tk. Since each file includes K1t1 sub-files with Tk, each user k satisfies the memory constraint H(Zk)=NFK1t1H(Wn,T)=NFt/K=MF.

For the convenience of understanding and reference, we give the algorithm of this scheme in Algorithm 1.

Algorithm 1 MAN Uncoded Symmetric Placement Scheme (N,K,M,W[N])
  • 1:

    tKM/N

  • 2:

    T{𝒯[K]:|𝒯|=t}

  • 3:

    for nN do

  • 4:

       Divide file Wn into disjoint sub-files (Wn,𝒯:𝒯T) with equal size

  • 5:

    end for

  • 6:

    for k[K] do

  • 7:

       Zk(Wn,𝒯:n[N],𝒯T, k𝒯)

  • 8:

    end for

The uncoded symmetric placement scheme is the optimal achievable placement scheme both for the shared-link model with uncoded cache placement [3] and D2D work with uncoded cache placement and one-shot delivery [9], which reveals that regardless of the number of users, using the uncoded symmetric placement scheme can satisfy the optimal rate of these models in all cases. Due to the superiority of the uncoded symmetric placement scheme, we use the scheme as the placement scheme in our scheme proposed in Section 4.

2.2.2. Problem of Coded Caching with Inactive Users

We denote our original D2D model with r users of K users requesting files independently in W as System 1. In order to derive the converse of System 1, we consider another system model named coded caching with inactive users, denoted as System 2. This is the model where a central server responds to the users’ requests, and some of the users do not request any files in the delivery phase. The central server connects to the whole file database.

The placement phase of System 2 is exactly the same as that of System 1. Thus, in System 2, Equation (3) is still satisfied. The delivery phase of System 2 is different from that of System 1. Specifically, in System 1, the codewords are transmitted by the users, while in System 2, the codewords are transmitted by the central server. Since the central server has the whole database and connects to all K users, while in System 1, each user only caches a subset of the whole database and only connects to other K1 users, the optimal maximum average and worst-case delivery rate in System 2, denoted as Rave,inactiver* and Rworst,inactiver*, can not be larger than the delivery rate in System 1, respectively. In other words, we have the following inequality:

Rave,req-robr*Rave,inactiver*, (4)
Rworst,req-robr*Rworst,inactiver*. (5)

3. Main Result

In this section, we present the main results of this work. We propose two achievable schemes for the request-robust D2D coded caching problem in Theorems 1 and 2. We further propose a converse for the problem of coded caching with inactive users in Theorem 3, which also serves as a converse result to the request-robust D2D coded caching problem. Theorem 4 compares the performance gap between the achievability result in Theorem 1 and the converse result in Theorem 3 and shows that they are within a multiplicative gap.

The first achievable scheme is obtained by adapting the achievable scheme in [9] with uncoded cache placement and one-shot delivery to the request-robust D2D coded caching problem. More specifically, the adaptation is performed by assigning the users, who do not request, a demand that is most requested by the requesters. We call the adapted scheme the adapted Yapar–Wan–Schaefer–Caire (YWSC) scheme. We denote the adapted request vector as DK and the adapted request vector of users K{k} as DK{k}. Hence, we have Ne(DK)=Ne(DR) and obtain Theorem 1 as follows:

Theorem 1.

For the request-robust D2D coded caching problem, the optimal maximum average delivery rate with respect to the uniform demand is upper bounded by

Rave,req-robr*EDKKK1ti=1KK1Ne(DK{i})tfKrtKr1ttKt, (6)

when t=KMN is an integer in [K], where f is an integer equal to one if and only if each requester demands a distinct file, i.e., Ne(DR)=r; otherwise, f=0. When t[K], Rave,req-robr* is upper bounded by the lower convex envelope of the values in (6) for integer values of t[K].

For the maximum worst-case delivery rate, we have

Rworst,req-robr*maxDKKK1ti=1KK1Ne(DK{i})tfKrtKr1ttKt, (7)
=KK1t(Kr)Kr1trKrttKt,rN,KK1t(2Nr)KNt(K+r2N)K1NttKt,otherwise,KK1tK1NttKt,r2N, (8)

where t=KMN is an integer in [K]. When t[K], Rworst,req-robr* is upper bounded by the lower convex envelope of the values in (7) for integer values of t[K].

Proof. 

The proof of Theorem 1 is provided in Appendix A. □

Theorem 1 is a simple adaptation of an existing scheme; in order to improve its performance, we propose a new scheme, called the three-category-based scheme, and obtain Theorem 2 as follows:

Theorem 2.

For the request-robust D2D coded caching problem, the optimal maximum average delivery rate with respect to the uniform demand is upper bounded by

Rave,req-robr*EDR{i=max{1,t+rK}min{t1,r1}Krtiri+1rNe(DR)i+1Kt+KrtNe(DR)Kt+rr1tiRr1Ne(DR{i})ttKt}, (9)

where t=KMN is an integer in [K]. When t[K], Rave,req-robr* is upper bounded by the lower convex envelope of the values in (9) for integer values of t[K].

Then, for the maximum worst-case delivery rate, we have

Rworst,req-robr*maxDR{i=max{1,t+rK}min{t1,r1}Krtiri+1rNe(DR)i+1Kt
+KrtNe(DR)Kt+rr1tiRr1Ne(DR{i})ttKt}, (10)
=i=max{1,t+rK}min{t1,r1}Krtiri+1Kt+rKrtKt+rr1ttKt,rN,i=max{1,t+rK}min{t1,r1}Krtiri+1rNi+1Kt+NKrtKt+rr1t(2Nr)rNt2(rN)r1NttKt,otherwise,i=max{1,t+rK}min{t1,r1}Krtiri+1rNi+1Kt+NKrtKt+rr1tr1NttKt,r2N, (11)

where t=KMN is an integer in [K]. When t[K], Rworst,req-robr* is upper bounded by the lower convex envelope of the values in (10) for integer values of t[K].

Proof. 

In proving Theorem 2, we propose a new scheme, i.e., the three-category-based scheme, where the sub-files are divided into three categories and different delivery signals are designed for each category. The detailed proof can be found in Section 4. □

Remark 1.

In Section 5, we numerically compare the delivery rates of the three-category-based scheme and the adapted YWSC scheme, and it can be seen that the proposed three-category-based scheme outperforms the adapted YWSC scheme in all cases cited (see Section 5 for the cited cases and comparison results).

In the following theorem, we characterize a converse for the request-robust D2D coded caching problem.

Theorem 3.

For the request-robust D2D coded caching problem, the optimal maximum average delivery rate with respect to the uniform demand and under the constraint of uncoded placement is lower bounded by:

Rave,req-robr*EDRKt+1KNe(DR)t+1Kt, (12)

where t=KMN is an integer in [K], where DR is uniformly distributed over DR. When t[K], Rave,req-robr* is lower bounded by the lower convex envelope of the values in (12) for integer values of t[K].

Then, for the maximum worst-case delivery rate, we have that the optimal maximum worst-case delivery rate under the constraint of uncoded placement is lower bounded by

Rworst,req-robr*Kt+1Kmin{r,N}t+1Kt, (13)

where t=KMN is an integer in [K]. When t[K], Rworst,req-robr* is lower bounded by the lower convex envelope of the values in (13) for integer values of t[K].

Proof. 

Similar to [9], we use the converse of the central server version, i.e., System 2, as a converse for the request-robust D2D coded caching problem when the converse is under the constraint of uncoded placement. The detailed proof is provided in Appendix B. □

We compare the rate achieved by the adapted YWSC scheme from Theorem 1 and the converse present in Theorem 3 and obtain a multiplicative gap result of Theorem 4 as follows:

Theorem 4.

For the request-robust D2D coded caching problem, the upper bounds of the optimal maximum average and worst-case rates from Theorem 1 are order optimal within a factor of two under the constraint of uncoded cache placement and within a factor of four in general.

Proof. 

The proof of Theorem 4 is given in Appendix D. □

Remark 2.

It is hard to analytically prove that the rate achieved by the three-category-based scheme from Theorem 2 outperforms the rate achieved by the adapted YWSC scheme from Theorem 1 in all cases. However, since in the numerical comparisons in Section 5 the three-category-based scheme performs better than the adapted YWSC scheme in all cases cited, we conjecture that the rate achieved by the three-category-based scheme from Theorem 2 and the converse present in Theorem 3 also follow the multiplicative gap characterized by Theorem 4.

4. A Novel Achievable Scheme, i.e., Proof of Theorem 2

In this section, we present an achievable scheme for the request-robust D2D coded caching problem. The scheme achieves the rate stated in Theorem 2. We will first provide a general achievable scheme, which is based on uncoded cache placement and exploiting common demands [11] and one-shot delivery [9]. Then, we will characterize the performance of the proposed scheme and show that for any requester set R and corresponding request vector DR, the proposed three-category-based scheme achieves the rate

Rreq-robDR=i=max{1,t+rK}min{t1,r1}Krtiri+1rNe(DR)i+1Kt+KrtNe(DR)Kt+rr1tiRr1Ne(DR{i})ttKt, (14)

which, with the explicit characterization of the maximum worst-case delivery rate in Section 4.2, immediately proves Theorem 2. Finally, we will provide an example to aid in a better understanding of the proposed three-category-based scheme.

4.1. General Scheme

For the placement phase, because the central server does not know the number of requesters r, we use the highly adaptable MAN uncoded symmetric placement scheme described in Definition 1, denoted as MMAN. In the following, we restrict to integer values of t[1:K]. For cache size M where t=KM/N is not an integer, memory-sharing will be performed [3,8].

For the delivery phase, let the set of requesters be R with size r. The r requesters each demand a single file. The delivery strategy is divided into the following steps:

  • (a)

    Determining the leading requesters: Each user kKR who does not request arbitrarily selects a subset of Ne(DR) requesters, denoted by Uk={u1k,...,uNe(DR)k}R, that request Ne(DR) distinct files. Using the idea of leaders from [11], we name these requesters as the leading requesters of User k.

  • (b)

    Splitting the sub-files into three categories: Recall that each sub-file is denoted as Wn,𝒯 and is cached by only users in 𝒯. If 𝒯KR, then this sub-file belongs to the first category, which is the set of sub-files that are only cached by users who do not request any files. If 𝒯 contains some elements from R and some elements from KR, then this sub-file belongs to the second category, which is the set of sub-files that are cached by both requesters and non-requesters. Finally, if 𝒯R, then this sub-file belongs to the third category, which is the set of sub-files that are only cached by users who make file requests.

The three categories may not all exist or be required by requesters, and it depends on the value of r and t. When t[Kr+1,K] or r=K, the first category does not exist. When t=1 or r=K, the second category does not exist, and when r=1 or t=K, the second category is not required. When t[r+1,K], the third category does not exist, and when t=r or r=1, the third category is not required.

  • (c)

    Transmitting signals for the sub-files in the three categories: we will discuss the delivery scheme for the sub-files in each of the three categories.

  • (i)
    For the sub-files in the first category needed by Requester k,kR, since these sub-files are not cached in any of the requesters, the users in KR who cache these sub-files transmit them in an uncoded form. Suppose Wdk,𝒯 is requested by User kR, 𝒯KR, any of the t users in 𝒯 can transmit the sub-file in an uncoded form. However, we adopt the file-splitting strategy in [9] and allow each user in 𝒯 to transmit 1/t part of the sub-file, i.e., Wdk,𝒯 is divided into t pieces, each consisting of FtKt numbers of bits. The pieces are denoted as Wdk,𝒯,a, a𝒯, and User a transmits
    Xa1st,dk,𝒯=Wdk,𝒯,a. (15)
    We notice that Wdk,𝒯,a may be needed by other requesters, i.e., there may be other requesters that request file dk also. Hence, we let each user a transmit in sequence Xa1st,dk,𝒯 for all kUa. Hence, the rate of transmitting total bits for the sub-files in the first category is
    R1st=tKrtNe(DR)tKt=KrtNe(DR)Kt, (16)
    because for each 𝒯, every user a𝒯 transmits Ne(DR)FtKt bits, and there are t users in each 𝒯, and a total of Krt number of 𝒯 that are subsets of KR.
  • (ii)

    Consider a sub-file in the second category needed by Requester k,kR, denoted as Wdk,𝒯, where k𝒯. Denote the set of elements in 𝒯 that are in R as B, whose size is denoted as i, and we have 1ir1, because we know at least User k who is requesting a file is not in 𝒯. Further denote the set of elements of 𝒯 that are in KR as B^, whose size is ti, and we have 1tiKr. Hence, 𝒯 can be written as 𝒯=BB^. Furthermore, i must satisfy i[max{1,t+rK},min{t1,r1}].

Consider the set B¯{k}B, which is a set consisting of i+1 requesters. The sub-file Wdx,B^B¯{x} is needed for xB¯. We ask that this sub-file be transmitted by the ti non-requesters, and Wdx,B^B¯{x} for any xB be divided into ti equal-length disjoint sub-pieces of F(ti)Kt bits, which are denoted by Wdx,B^B¯{x},b, where bB^. Hence, if User bB^ transmits

Xb2nd,dx,B^B¯{x}=xB¯Wdx,B^B¯{x},b, (17)

the sub-piece retrieval can be accomplished for each requester in B¯ since User x has all the sub-pieces on the RHS of (17), except for Wdx,B^B¯{x},b.

We ask each user bKR to transmit Xb2nd,dx,B^B¯{x} in sequence, only if B¯Ub, i.e., user b will not transmit if the set B¯ consists of only non-leading requesters. We now count the amount of transmission for the second category. For a fixed i, the number of B^, which is of size ti, is Krti. For each uB^, the number of transmitted bits is ri+1rNe(DR)i+1 times the size of a sub-piece, and there are a total of ti users in B^. Hence, the rate of transmitting all the bits for the sub-files in the second category is

R2nd=i=max{1,t+rK}min{t1,r1}Krtiri+1rNe(DR)i+1Kt. (18)

The next lemma shows that the scheme proposed satisfies the decodability constraint, even for the non-leading requesters.

Lemma 1.

The scheme proposed for the sub-files in the second category satisfies the decodability constraint, i.e., (2).

The proof of Lemma 1 is based on showing the equivalence of the designed scheme and that in [11]. Hence, we state the following remark first:

Remark 3.

Notice that when the sub-files are in the second category and the parameter t is fixed, for each partition integer i, a user bB^ generates its codewords exclusively from the sub-pieces Wdk,B^B,b, and there exist ri such sub-pieces in its cache. In addition, for any cB^{b}, we have Wdk,B^Vb,bWdl,B^Vc,c= for any Vb,VcR,|Vb|=|Vc|=i,kVb,lVc. That is to say, users in B^ generate their codewords based on non-overlapping libraries of size (ti)NriF(ti)Kt=NriF/Kt bits. Also, observe that the cache of requester k contains (ti)r1i1 such Wdk,B^Vb,b sub-pieces, which amount to N(ti)r1i1F(ti)Kt=Nr1i1FKt=NirtFrKt bits.

Therefore, the proposed scheme is in fact composed of (ti) shared-link models [3] each with N files of size F=riF/Kt bits and K=r users with caches of size M=Ni/r units each. The corresponding parameter for each model is found to be t=KMN=i. To ensure the existence of sub-files in the second category, the partition integer must satisfy i[max{1,t+rK},min{t1,r1}]. Hence, for every i[max{1,t+rK},min{t1,r1}], summing the achievable rates Rsl, which is defined as follows from [11]:

Rsl=Kt+1KNe(d)t+1Kt, (19)

of each bB^ shared-link sub-system and replacing the shared-link system parameters F,K,M,t,and Ne(d) with F,K,M,t,and Ne(DR), respectively, we obtain (18).

We now prove that for each partition integer i[max{1,t+rK},min{t1,r1}], each requester k is able to decode the needed sub-files in the second category with the partition integer i upon receiving the codewords Xb2nd,dk,B^B¯{k} for all bB^.

When k is a leading requester of the user b who does not request, i.e., kUb, it can decode any required sub-piece Wdk,B^Pk,b, where PkR{k},|Pk|=i, from Xb2nd,dk,B^Pk, which is broadcast from user b by performing

Wdk,B^Pk,b=xPkWdx,B^Pk{k}{x},bXb2nd,dk,B^Pk,

as can be seen from (17).

When kUb, it is less straightforward for the non-leading requester k to decode the needed sub-files, because not all of the corresponding codewords Xb2nd,dk,B^Pk for its required sub-pieces Wdk,B^Pk,b are directly broadcast from user b. However, Requester k can generate these codewords simply based on the codewords received. To show this, we reformulate the following Lemma 2 from [11] (Lemma 1), which is applied to the codewords broadcast by the user b with the partition integer i.

Lemma 2.

Given an integer t, a partition integer i, a subset B^KR of size ti, a user bB^, and a set of leading requesters Ub, for any subset CbR that includes Ub, let VFb be family of all subsets Vb of Cb such that each requested file in DR is requested by exactly one user in Vb. The following equation holds:

VbVFbXb2nd,dk,B^{CbVb}{k}=0, (20)

if each Xb2nd,dk,B^{CbVb}{k} is defined in (17).

Proof. 

As we mentioned in Remark 3, for the sub-files needed in the second category, when the parameters t and i are fixed, the proposed scheme, in fact, corresponds to (ti) shared-link schemes. Thus, Ref. [11] (Lemma 1) can directly be applied to each b-th shared-link scheme. □

Let us now consider any subset B¯ of i+1 non-leading requesters of user b such that B¯Ub=. Using (20), the following equation can be derived:

Xb2nd,dk,B^B¯{k}=VbVFb{Ub}Xb2nd,dk,B^{CbVb}{k}, (21)

where Cb=BiUb. Equation (21) shows that the codeword Xb2nd,dk,B^B¯{k} can be directly computed from the broadcast codewords transmitted to all the leading requesters of b, because all codewords on the RHS of (21) are directly broadcasted by user b. Hence, each requester k can obtain the value Xb2nd,dk,B^B¯{k} for any subset B¯ of i+1 requesters and can decode its demanded sub-pieces as discussed before. Hence, Lemma 1 is proved.

  • (iii)

    Lastly, we consider the sub-files in the third category. Since all the sub-files needed for delivery are only cached in the requesters, the transmission will happen only among requesters. This is equivalent to the D2D coded caching model considered in [9], and we adopt its achievable scheme with uncoded cache placement and one-shot delivery, which we call the Yapar–Wan–Schaefer–Caire (YWSC) scheme.

More specifically, during the delivery phase, each sub-file is divided into t equal-length disjoint sub-pieces of FtKt bits, which are denoted by Wn,𝒯,i,i𝒯. Further, each user i in requester set R, where |R|=r, selects an arbitrary subset of Ne(DR{i}) users from R{i}, denoted by Ui={u1i,...,uNe(DR{i})i}, which request Ne(DR{i})) distinct files and are referred to as leading demanders of user i. Then, for all subsets EiR{i} of t users, each user i transmits

Xi3rd={YEii}EiUi, (22)

where

YEii=kEiWdk,{Ei{i}}{k},i. (23)

In other words, since all users kEi shall retrieve the needed sub-pieces Wdk,{Ei{i}}{k},i from the transmissions of User i, using the idea of leaders from [11], each user i only needs to transmit in sequence the codewords YEii for all subsets Ei such that EiUi, i.e., Xi3rd.

As a result, when User k is a leading demander for User i, i.e., kUi, it can decode any needed sub-piece Wdk,Gk{i},i, where GkR{i,k}, |Gk|=t1, from YGk{k}i, which is transmitted from User i by performing

Wdk,Gk{i},i=xGkWdx,{Gk{i,k}}{x},iYGk{k}i.

When User k is not a leading demander for User i, using the equation

ViVFiYCiVii=0,

proved in [9] (Lemma 1), where subset CiR{i} includes Ui and VFi denotes the family of all subsets Vi of Ci such that each requested file in DR{i} is requested by exactly one user in Vi, each user k can decode its requested sub-piece through obtaining the value YEii, for any subset Ei of t users such that EiUi=, from the broadcast codewords by the following equation:

YEii=ViVFi{Ui}YCiVii, (24)

where Ci=EiUi. To sum up, for each iR{k}, User k decodes its requested sub-pieces by following either one of the strategies above, depending on whether it is a leading demander of User i or not.

For each user iR, the size of the transmitted signal amounts to r1tr1Ne(DR{i})t times the size of a sub-piece. Hence, the rate of transmitting all the bits for the sub-files in the third category is

R3rd=rr1tiRr1Ne(DR{i})ttKt, (25)

In other words, the equivalence of the above scheme and that of [9] can be seen in the following remark:

Remark 4.

For the sub-files in the third category, the proposed scheme is equivalent to that of [9]. The central server has a library of N files, Wn,𝒯|𝒯R,|𝒯|=t, and each file has F˜rtFKt bits. There are r D2D users in the system, each requesting a single file. Based on the MAN uncoded symmetric placement scheme adopted, the placement is the same as [9], where each sub-file has the size of FKt, which is equal to F˜rt, and sub-file Wn,𝒯 is placed in users in 𝒯. Thus, each user caches a total of Nr1t1 sub-files. Hence, each user has a memory of

M˜=Nr1t1FKt

bits, and we can check that

rM˜NF˜=t,

just as in [9]. Hence, for the sub-files in the third category, the equivalence between the proposed cache placement scheme and that of [9] is established. In other words, corresponding to the parameters (F,N,K,MF,t,andNe(d)) in [9], which denote the file size, number of files, number of users, cache size of each user, the parameter defined as t=KMFNF, and the number of users requesting different files, respectively, we have F˜,N,r,M˜,t,andNe(DR) in our problem.

Summing up the three sub-schemes mentioned above, every requester can decode its requested file. Meanwhile, combining the rate from (16), (18), and (25), the total rate of this delivery scheme is Rreq-robDR=R1st+R2nd+R3rd, which results in the rate stated in (14). The description of this subsection with the explicit characterization of the maximum worst-case delivery rate in Section 4.2, directly proves Theorem 2. More specifically, since the proposed scheme is symmetric with respect to the users, any R with |R|=r will offer the same average delivery rate Rave,req-robR and the same worst-case delivery rate Rworst,req-robR.

Remark 5.

The difference in transmitting the sub-files in the three categories is that the transmissions of the sub-files in the first and third categories both adopt the one-shot delivery scheme in [9], while the transmission of the sub-files in the second category adopts the common demands scheme in [11]. Moreover, the transmission of the sub-files in the first category is in uncoded form, while the transmissions of the sub-files in the second and third categories are both with coded multi-casting opportunity.

We formally write the three-category-based scheme in Algorithm 2.

Algorithm 2 Three-category-based Scheme (N,K,M)
  • procedure 

    PLACEMENT(W1,,WN)

  •   1:

    Apply Algorithm 1 MAN Uncoded Symmetric Placement Scheme (N,K,M,W[N])

  • end procedure 

     

  • procedure 

    DELIVERY(R,DR)

  •   2:

    r|DR|

  •   3:

    tKM/N

  •   4:

    Ne(DR) the number of distinct elements in DR

  •   5:

    for  k[K]R  do

  •   6:

    Uk{u1k,,uNe(DR)k}

  •   7:

    end for

  •   8:

    (i) For sub-files in the first category:

  •   9:

    T{𝒯[K]R:|𝒯|=t}

  • 10:

    for  𝒯T do

  • 11:

    for  n[N]  do

  • 12:

      Divide sub-file Wn,𝒯 into t disjoint sub-pieces (Wn,𝒯,a:a𝒯) with equal size

  • 13:

    end for

  • 14:

    for  a𝒯  do

  • 15:

      for  sUa  do

  • 16:

       User a transmit Xa1st,ds,𝒯=Wds,𝒯,a

  • 17:

      end for

  • 18:

    end for

  • 19:

    end for

  • 20:

    (ii) For sub-files in the second category:

  • 21:

    for  [max{1,t+rK},min{t1,r1}]  do

  • 22:

     Ɓ  {B^[K]R:|B^|=ti}

  • 23:

    for  B^ Ɓ  do

  • 24:

      for  BR:|B|=i  do

  • 25:

       for  n[N]  do

  • 26:

        Divide sub-file Wn,BB^ into ti disjoint sub-pieces (Wn,BB^,b:bB^) with equal size

  • 27:

       end for

  • 28:

      end for

  • 29:

      for  bB^  do

  • 30:

       for  B¯R:|B¯|=i+1  do

  • 31:

        if  B¯Ub==  then

  • 32:

         continue

  • 33:

        else

  • 34:

         User b transmits Xb2nd,dx,B^B¯{x}=xB¯Wdx,B^B¯{x},b

  • 35:

        end if

  • 36:

       end for

  • 37:

      end for

  • 38:

    end for

  • 39:

    end for

  • 40:

    (iii) For sub-files in the third category:

  • 41:

    𝒢  {G[K]:|G|=t}

  • 42:

    for  n[N]  do

  • 43:

    for  G 𝒢  do

  • 44:

      Divide sub-file Wn,G into t disjoint sub-pieces (Wn,G,i:iG) with equal size

  • 45:

    end for

  • 46:

    end for

  • 47:

    for  iR  do

  • 48:

    Ne(DR{i}) the number of distinct elements in DR{i}

  • 49:

    Ui{u1i,...,uNe(DR{i})i}

  • 50:

    for EiR{i}:|Ei|=t users do

  • 51:

      if  EiUi==  then

  • 52:

       continue

  • 53:

      else

  • 54:

       User i transmits YEii=kEiWdk,{Ei{i}}{k},i

  • 55:

      end if

  • 56:

    end for

  • 57:

    end for

  • end procedure 

     

4.2. The Maximum Worst-Case Delivery Rate

In this subsection, we characterize the performance of the proposed three-category-based scheme for the maximum worst-case delivery rate. The characterization is based on the observation that the binomial coefficient nm demonstrates a strictly ascending pattern with respect to n.

For the request-robust D2D coded caching problem, when N,K,M,r,andR do not change, since the upper bound rate Rreq-robDR from (14) decreases as Ne(DR) decreases, the upper bound rate for the maximum worst-case delivery rate is the one at the maximum value of Ne(DR), i.e.,

Ne(DR)=min{r,N}. (26)

Then, for r2N, each file can be requested by at least two requesters, which leads to Ne(DR{i}),iR having the maximum value of N. Hence, this case maximizes the upper bound rate Rreq-robDR.

For r<2N, a requester i may be the only user requesting a file or not, which leads to Ne(DR{i})=Ne(DR)1 and Ne(DR{i})=Ne(DR), respectively. Hence, due to (26), for rN, we have r1Ne(DR{i})t=0, which proves the case where rN.

For N<r<2N, we have Ne(DR)=N and then obtain that each file cannot be requested by more than two requesters. Thus, due to a total of r requesters, there are 2Nr requesters, each of which are the only users requesting a file while each of the remaining 2(rN) requesters are not. Thus, we prove the case where N<r<2N.

4.3. Example

To aid in better understanding, we provide an example to illustrate the proposed scheme in Section 4.1.

Let us consider a case where N=2,K=6,andM=2/3. Hence, t=KM/N=2. In the placement phase, each file is divided into 62=15 sub-files, and each sub-file’s index is in T, where T is the family of all sets 𝒯 such that 𝒯[6],|𝒯|=2. The user k[6] caches the following sub-files for each n{1,2}:

Zk={Wn,𝒯|𝒯T,k𝒯}.

In the delivery phase, without a loss of generality, we consider only Users 1,2,3,and4 as requesters, each requesting a single file, i.e., R={1,2,3,4}, and the request vector is D{1,2,3,4}=(1,2,1,1). Notice that r=4 and Ne(D{1,2,3,4})=2. Requesters 1,2,3,and4 need the following missing sub-files:

W1Z1={W1,{2,3},W1,{2,4},W1,{2,5},W1,{2,6},W1,{3,4},W1,{3,5},W1,{3,6},W1,{4,5},W1,{4,6},W1,{5,6}},W2Z2={W2,{1,3},W2,{1,4},W2,{1,5},W2,{1,6},W2,{3,4},W2,{3,5},W2,{3,6},W2,{4,5},W2,{4,6},W2,{5,6}},W1Z3={W1,{1,2},W1,{1,4},W1,{1,5},W1,{1,6},W1,{2,4},W1,{2,5},W1,{2,6},W1,{4,5},W1,{4,6},W1,{5,6}},W1Z4={W1,{1,2},W1,{1,3},W1,{1,5},W1,{1,6},W1,{2,3},W1,{2,5},W1,{2,6},W1,{3,5},W1,{3,6},W1,{5,6}}.

In Step (a), determining the leading requesters without a loss of generality, we assume that User 5 picks Users 1and2 and User 6 picks Users 2and3 as the leading requesters, i.e., U5={1,2},U6={2,3}.

In Step (b), we split the sub-files into three categories. More specifically, Wn,{5,6}, n[N] belong to the first category; Wn,{1,5}, Wn,{1,6}, Wn,{2,5}, Wn,{2,6}, Wn,{3,5}, Wn,{3,6}, Wn,{4,5}, Wn,{4,6}, n[N] belong to the second category; and Wn,{1,2}, Wn,{1,3}, Wn,{1,4}, Wn,{2,3}, Wn,{2,4}, Wn,{3,4} belong to the third category.

In Step (c) of delivering signals, for the sub-files belonging to the first category, i.e., sub-files only cached by Users 5 and 6, after splitting these sub-files into two equal-length sub-pieces, from (15), we know that User 5 transmits

W1,{5,6},5,W2,{5,6},5,

and User 6 transmits

W1,{5,6},6,W2,{5,6},6,

which are all directly needed by the requesters. The rate R1st=1/30×2×2=2/15, which coincides with (16).

For the sub-files in the second category, since i must satisfy i[max{1,t+rK},min{t1,r1}], in this example, we only need to consider i=1, which means that ti=1. The fact that ti=1 means that none of these sub-files need to be further split. Take, for example, User 1 in R; it requires the sub-file W1,{2,5}. Thus, 𝒯={2,5}=BB^, where B={2} and B^={5}. Consider the set B¯={1}B={1,2} of i+1=2 users. Following from (17), if User {5} transmits

W1,{2,5}W2,{1,5},

both Users 1 and 2 will be able to obtain the sub-file they want, i.e., W1,{2,5} and W2,{1,5}, respectively. Similarly, we may consider all four users in R and the sub-files that each of them need. We find that if User {5} transmits

W1,{2,5}W2,{1,5},W1,{3,5}W1,{1,5},W1,{4,5}W1,{1,5},W2,{3,5}W1,{2,5},W2,{4,5}W1,{2,5},W1,{4,5}W1,{3,5},

and User {6} transmits

W1,{2,6}W2,{1,6},W1,{3,6}W1,{1,6},W1,{4,6}W1,{1,6},W2,{3,6}W1,{2,6},W2,{4,6}W1,{2,6},W1,{4,6}W1,{3,6},

all the requesting users will be able to decode the necessary sub-files of the second category. However, recall that U5={1,2} and U6={2,3}. Hence, the signal W1,{4,5}W1,{3,5} corresponds to B¯={3,4,5}, which has zero intersection with U5. Hence, W1,{4,5}W1,{3,5} need not be transmitted and can be calculated due to the fact that

(W1,{3,5}W1,{1,5})(W1,{4,5}W1,{1,5})(W1,{4,5}W1,{3,5})=0.

Similarly, W1,{4,6}W1,{1,6} need not be transmitted due to the fact that

(W1,{3,6}W1,{1,6})(W1,{4,6}W1,{3,6})(W1,{4,6}W1,{1,6})=0.

Hence, the rate R2nd=1/15×5×2=2/3, which coincides with (18).

For the sub-files in the third category, User 1 has R{1}={2,3,4}, which means Ne(DR{1})=2. Suppose User 1 picks the leading demanders as U1={2,4}. Similarly, User 2 has R{2}={1,3,4}, which means Ne(DR{1})=1. Suppose User 2 picks the leading demanders as U2={3}. User 3 has R{3}={1,2,4}, which means Ne(DR{1})=2. Suppose User 3 picks the leading demanders as U3={1,2}, and User 4 has R{4}={1,2,3}, which means Ne(DR{1})=2. Suppose User 4 picks the leading demanders as U1={2,3}.

Since t=2, we split the sub-files in the third category into two equal-length sub-pieces. For User 1, E1 is of size t=2 and is a subset of R{1}={2,3,4}. Hence, possible E1s can be {2,3},{2,4},and{3,4}, which all satisfy the condition of non-zero intersection with U1={2,4}. Hence, from (22) and (23), User 1 transmits

Y{2,3}1=W2,{1,3},1W1,{1,2},1,Y{2,4}1=W2,{1,4},1W1,{1,2},1,Y{3,4}1=W1,{1,4},1W1,{1,3},1.

Similarly, User 3 transmits

Y{1,2}3=W1,{2,3},3W2,{1,3},3,Y{1,4}3=W1,{3,4},3W1,{1,3},3,Y{2,4}3=W2,{3,4},3W1,{2,3},3,

and User 4 transmits

Y{1,2}4=W1,{2,4},4W2,{1,4},4,Y{1,3}4=W1,{3,4},4W1,{1,4},4,Y{2,3}4=W2,{3,4},4W1,{2,4},4.

As for User 2, E2 is of size t=2 and is a subset of R{2}={1,3,4}. Hence, possible E2s can be {1,3},{1,4},and{3,4}. Recall that U2={3}; hence, only {1,3} and {3,4} satisfy the condition of non-zero intersection with U2={3}. Hence, from (22) and (23), User 2 transmits

Y{1,3}2=W1,{2,3},2W1,{1,2},2,Y{3,4}2=W1,{2,4},2W1,{2,3},2.

The signal Y{1,4}2=W1,{2,4},2W1,{1,2},2 does not need to be transmitted and can be calculated since Y{1,3}2Y{3,4}2Y{1,4}2=0 (cf. (24)). Hence, the rate R3rd=1/30×(3×3+2)=11/30, which coincides with (25).

Thus, the total delivery rate achieved by the proposed scheme for the case R={1,2,3,4} and the request vector is D{1,2,3,4}=(1,2,1,1) is 215+23+1130=76. In this case, if we directly use the YWSC scheme [9] by assigning Users 5 and 6 a demand that is the same as Users 1, 3, and 4, i.e., all six users make file requests, and the demand vector is d={1,2,1,1,1,1}, then according to [9] (Equation (14)), the delivery rate is 6×10(3×5+6)30=1310. If we assign Users 5 and 6 with some other demands, the delivery rate will be even higher. Hence, we see that for the request-robust D2D coded caching problem, the proposed scheme performs better than directly applying the YWSC scheme for this example.

The reason why the proposed three-category-based scheme has better performance is that directly applying the YWSC scheme may contain information that is useful for users who do not request files, which is useless for requesters and difficult to be excluded. We provide more details in the following remarks:

Remark 6.

When each user requests a single file (r=K), our proposed scheme corresponds to the one originally presented in [9]. The improvement in our scheme is that when r<K, we take full advantage of the users who do not request files so that the broadcast codewords are only useful to the requesters. Moreover, through the numerical comparison in Section 5, we find that letting the users who do not request files broadcast pieces of sub-files in the first and second categories, i.e., sub-files in {Wn,A|A{k},kKR}, incurs a much smaller rate than letting all the users participate in broadcasting the required pieces of sub-files in all three categories.

Remark 7.

The proposed scheme is symmetric in the placement phase. As mentioned in [9] (Remark 6), under the constraints of uncoded cache placement, the shared link models in [11,27] showed the optimality of symmetry in the placement phase [3]. This symmetry happens in the placement phase before the requesters are identified and reveal their demands, and any asymmetry in the placement will certainly not result in a better worst-case rate. However, due to the file-categorization step (i.e., Step (b)), the delivery phase of the proposed scheme is asymmetric, while if the value of Ne(DR{i}) is the same for every iR, the delivery phase of directly applying the YWSC scheme (i.e., the adapted YWSC scheme (see Appendix A for the specific scheme)) is symmetric. Interestingly, the asymmetric delivery phase of the proposed scheme outperforms the possibly symmetric delivery phase of directly applying the YWSC scheme both for the maximum average and worst-case delivery rate in all cases cited, as shown in Section 5.

Remark 8.

The delivery phase of the proposed scheme is actually one-shot, which is defined in [9] as meaning that each user k can recover the i-th needed bit denoted as Wdkk(i) from its own cache and the transmission of a single other user whose index is jk(i), i.e., H(Wdkk(i)|Xjk(i),Zk)=0 holds. One-shot delivery allows all users to participate in the transmission without causing users to repeatedly broadcast the same codeword. However, it is difficult to confirm whether the proposed scheme is optimal under the constraint of uncoded cache placement and one-shot delivery since the delivery scheme as mentioned in Remark 7 is asymmetric.

Remark 9.

The rate achieved by the three-category-based scheme from (14) outperforms the rate achieved by the adapted YWSC scheme from (A1) in some specific cases. For example, for r=2 and the maximum worst-case delivery rate, when t[2,K1],rN, we have

Radapted-YWSCDR|r=2,t[2,K1],rN=KK1t(K2)K21t2K2ttKt=(2Kt1)K2t1tKt>(2Kt2)K2t1tKt=K2t121+1Kt+2K2tKt (27)
=Rreq-robDR|r=2,t[2,K1],rN, (28)

where (27) is from (8) and (28) is from (11). Meanwhile, when t[2,K1],r>N, i.e., N=1, we have

Radapted-YWSCDR|r=2,t[2,K1],N=1=KK1tK2ttKt=1Kt·K(K2)!t!(Kt1)!>1Kt·(K1)!t!(Kt1)!=K2t121+1Kt+K2tKt (29)
=Rreq-robDR|r=2,t[2,K1],N=1, (30)

where (29) is from (8) and (30) is from (11). Moreover, tK, i.e., MN, is trivial, and when t=1, the three-category-based scheme and the adapted YWSC have the same performance. Hence, for r=2 and the maximum worst-case delivery rate, the three-category-based scheme outperforms the adapted YWSC scheme for all values of K,N,t.

5. Numerical Evaluations

In this section, we compare the rate–memory tradeoff of the three-category-based scheme, the adapted YWSC scheme, and the achievable schemes in [8], adapted to the request-robust D2D coded caching scenario. The adaptation is performed by assigning the users, who do not request, a demand that is most requested by the requesters. We also plot the converse bounds on the optimal average and worst-case delivery rate of the request-robust D2D coded caching problem in Theorem 3.

We consider the cases where the value of K is from 1 to 60. For a fixed K, we consider that the value of N is from 1 to K. The performance metrics are the maximum average delivery rate with respect to the uniform demand and the maximum worst-case delivery rate, i.e., Rave,req-robr and Rworst,req-robr. We find that, in these cases, our proposed three-category-based scheme outperforms the adapted YWSC scheme and the adapted schemes of [8] for all possible r.

Take the example where N=10,K=30. As shown in Figure 2, the performance of the proposed scheme is given by the red solid line when r=20 and the purple solid line with dots when r=5. These lines are plotted according to the right-hand side (RHS) of (9) and (10). The performance of the adapted YWSC scheme is given by a blue dash–dot line when r=20 and a cyan dash–dot line with dots when r=5. These lines are plotted according to the RHS of (6) and (7). The proposed converse is given by the black dotted line when r=20 and the orange dotted line with asterisks when r=5. Since the achievable rate in [8] is independent of the demand, the performance of the adapted scheme from [8] does not change with the value of r and is given by the green dashed line. For the maximum worst-case rate, we also provide the lower bound in [8] adapted to the request-robust D2D coded caching scenario with the brown dashed line with dots. It can be seen that our proposed scheme outperforms the adapted YWSC scheme and adapted scheme of [8] in this case; meanwhile, the proposed converse is rather tight compared to the adapted lower bound in [8].

Figure 2.

Figure 2

Consider the request-robust D2D coded caching problem from Section 2.1 where N=10andK=30. The figure above is for the tradeoff between memory size and the maximum worst-case delivery rate for different requester numbers. The figure below shows the tradeoff between memory size and the maximum average delivery rate under uniform demand for different requester numbers. The scheme and converse proposed by Ji et al. [8] are both adapted to this request-robust D2D scenario.

6. Conclusions

In this paper, we propose a new problem called request-robust D2D coded caching, where in the delivery phase, though all users in the placement phase are still present, some of them do not request any files. We presented an achievable scheme for this problem based on uncoded cache placement and exploiting common demands and one-shot delivery. The caching strategy is the same as that proposed by Maddah-Ali and Niesen, while the delivery strategy divides the sub-files into three categories, and different delivery signals are designed for each category. We also characterized information-theoretic lower bounds for the request-robust D2D coded caching problem under the constraint of uncoded cache placement. The lower bounds are both for the maximum average delivery rate under uniform demand and the maximum worst-case delivery rate. We adapt the scheme proposed by Yapar et al. for uncoded cache placement and one-shot delivery to the request-robust D2D coded caching problem. The adaptation is performed by assigning the users, who do not request, a demand that is the most requested by the requesters. The performance of the adapted scheme is proved to be order optimal within a factor of two under uncoded cache placement and within a factor of four in general. Finally, by numerical evaluation, we show that the proposed scheme outperforms the known D2D coded caching schemes applied to the request-robust scenario.

Appendix A. Adapted Yapar–Wan–Schaefer–Caire Scheme, i.e., Proof of Theorem 1

In this section, we present another achievable scheme that adapts the YWSC scheme from [9] for the request-robust D2D coded caching problem. The scheme achieves the rate stated in Theorem 1.

We will first provide the general achievable scheme, which is based on the uncoded cache placement and exploiting one-shot delivery [9]. Then, we will characterize the performance of the proposed scheme and show that for any requester set R and corresponding request vector DR, the adapted YWSC scheme achieves the rate

Radapted-YWSCDR=KK1ti=1KK1Ne(DK{i})tfKrtKr1ttKt, (A1)

where DK is the request vector of all the users after adaption, and f is an integer equal to one if and only if each requester demands a distinct file; otherwise, f=0. The rate Radapted-YWSCDR with the explicit characterization of the maximum worst-case delivery rate in Appendix A.2 immediately proves Theorem 1. Finally, we will provide an example to aid in a better understanding of the adapted YWSC scheme.

Appendix A.1. General Scheme

Similar to Section 4.1, for the placement phase, we still use MMAN described in Definition 1. In the following, we restrict to integer values of t[1:K]. For cache size M where t=KM/N is not an integer, memory-sharing will be performed [3,8].

For the delivery phase, let the set of requesters be R with size r. The r requesters each demand a single file. We find that the YWSC scheme from [9] is highly adaptable for the request-robust D2D coded caching scenario. The adaptation is performed by assigning the users, who do not request, a demand that is the most requested by the requesters. If there are multiple demands that are the most requested, the users, who do not request, would be assigned one of the demands. Recall that we denote the adapted request vector as DK, and the adapted request vector of users K{k} as DK{k}. For example, if K=N=4,R={1,2},D{1,2}={1,4}, we have D{1,2,3,4}={1,4,1,1} or D{1,2,3,4}={1,4,4,4}. Obviously, Ne(DK)=Ne(DR) and Ne(DK{k})Ne(DR{k}) for each kR.

Next, to adapt the YWSC scheme for the system model, the delivery strategy is divided into the following steps:

  • (a)

    Determining the leading demanders: Recall that each sub-file is denoted as Wn,𝒯 and is cached by only users in 𝒯. Each sub-file is divided into t equal-length disjoint sub-pieces of FtKt bits, which are denoted by Wn,𝒯,i,i𝒯. Further, each user i selects an arbitrary subset of Ne(DK{i}) users from K{i}, denoted by Ui={u1i,,uNe(DK{i})i}, which request Ne(DK{i})) distinct files and are referred to as leading demanders of user i.

Without a loss of generality, we assume that the leading demanders of each user i are determined from the requesters as much as possible and are denoted by Ui¯. For example, for K=N=3,R={1,2},D{1,2}={1,3},D{1,2,3}={1,3,1}, the leading demander of User 2 in the assumption is U2¯={1} and should not be {3}, while the leading demander of User 1 is U1¯={2,3}.

  • (b)
    Pre-transmitting signals: Then, for all subset EiK{i} of t users, each user i prepares for transmitting:
    XiYWSC={YEii}EiUi, (A2)
    where
    YEii=kEiWdk,{Ei{i}}{k},i, (A3)
    which is the same as (23). In other words, since all users kEi shall retrieve the needed sub-pieces Wdk,{Ei{i}}{k},i from the transmissions of User i, using the idea of leaders from [11], each user i only need to transmit in sequence the codewords YEii for all subsets Ei such that EiUi, i.e., XiYWSC.
  • (c)

    Removing unwanted codewords: We notice that the codewords that are only useful for the users, who do not request, are unwanted codewords and do not need to be transmitted. Next, we will remove the unwanted codewords.

Recall that each user i only prepares for transmitting the codewords YEii where EiUi¯. For user i, when Ui¯KR=, the signal XiYWSC does not have unwanted codewords. When Ui¯KR, the signal XiYWSC may have the codewords YEii where EiKR, which are only useful for the users, who do not request, and should be removed. Obviously, if and only if each requester demands a distinct file, we have Ui¯KR for only one requester i in R. Hence, for all subsets EiK{i} of t users, each user i transmits

Xiadapted-YWSC={YEii}EiUi¯,EiKR,

where YEii is defined in (A3).

As a result, when Requester k is a leading demander for User i, i.e., kUi, it can decode any needed sub-piece Wdk,Gk{i},i, where GkK{i,k}, |Gk|=t1, from YGk{k}i, which is transmitted from User i, by performing

Wdk,Gk{i},i=xGkWdx,{Gk{i,k}}{x},iYGk{k}i.

When Requester k is not a leading demander for User i, using the equation

ViVFiYCiVii=0,

proved in [9] (Lemma 1), where subset CiK{i} includes Ui¯ and VFi denotes the family of all subsets Vi of Ci such that each requested file in DK{i} is requested by exactly one user in Vi, each user k can decode its requested sub-piece through obtaining the value YEii for any subset Ei of t users such that EiUi¯= from the broadcast codewords by the following equation:

YEii=ViVFi{Ui¯}YCiVii,

where Ci=EiUi¯. To sum up, for each iK{k}, Requester k decodes its requested sub-pieces by following either one of the strategies above depending on whether it is a leading demander of User i or not.

For each user iK, the size of the transmitted signal amounts to K1tK1Ne(DK{i})t times the size of a sub-piece. Meanwhile, if we have Ui¯KR for only one requester i in R, the size of the removed unwanted codewords amounts to KrtKr1t times the size of a sub-piece. Hence, the rate of transmitting total bits coincides (A1).

For the convenience of understanding, we give the algorithm of the adapted YWSC scheme in Algorithm A1.

Algorithm A1 Adapted YWSC Scheme (N,K,M)
  • procedure 

    PLACEMENT(W1,,WN)

  •   1:

    Apply Algorithm 1 MAN Uncoded Symmetric Placement Scheme(N,K,M,W[N])

  • end procedure 

     

  • procedure 

    DELIVERY(R,DR)

  •   2:

    r|DR|

  •   3:

    tKM/N

  •   4:

    Assign the users, who do not request, a demand that is the most requested by the requesters and has DKDR

  •   5:

    𝒢  {G[K]:|G|=t}

  •   6:

    for  n[N]  do

  •   7:

    for  G 𝒢 do

  •   8:

      Divide sub-file Wn,G into t disjoint sub-pieces (Wn,G,i:iG) with equal size

  •   9:

    end for

  • 10:

    end for

  • 11:

    for  iK  do

  • 12:

    Ne(DK{i}) the number of distinct elements in DK{i}

  • 13:

    Ui¯{u1i,...,uNe(DK{i})i} from R as much as possible

  • 14:

    for EiK{i}:|Ei|=t users do

  • 15:

      if  EiUi¯==  then

  • 16:

       continue

  • 17:

      else if EiKR then

  • 18:

       continue

  • 19:

      else

  • 20:

       User i transmits YEii=kEiWdk,{Ei{i}}{k},i

  • 21:

      end if

  • 22:

    end for

  • 23:

    end for

  • end procedure 

     

Appendix A.2. The Maximum Worst-Case Delivery Rate

In this section, we characterize the performance of the adapted YWSC scheme for the maximum worst-case delivery rate. The characterization is based on the observation that the binomial coefficient nm demonstrates a strictly ascending pattern with respect to n.

Again, the adaptation is performed by assigning the users, who do not request, a demand that is the most requested by the requesters, and we have Ne(DK)=Ne(DR). Meanwhile, f from (A1) is an integer equal to one if and only if each requester demands a distinct file, i.e., Ne(DR)=r; otherwise, f=0. Hence, for the request-robust D2D coded caching problem, when N,K,M,r,andR do not change, since the upper bound rate Radapted-YWSCDR from (A1) decreases as Ne(DK) decreases, the upper bound rate for the maximum worst-case delivery rate is the one at the maximum value of Ne(DK), i.e., Ne(DK)=min{r,N}.

Then, for r2N, each file can be requested by at least two users, which leads to Ne(DK{k}),kK having the maximum value of N. Meanwhile, in this case, f=0. Hence, this case maximizes the upper bound rate Radapted-YWSCDR.

For r<2N, User k may be the only user requesting a file or not, which leads to Ne(DK{k})=Ne(DK)1 and Ne(DK{k})=Ne(DK), respectively. Due to the adaption, for rN, there are r1 users, each of which are the only users requesting a file while each of the remaining Kr+1 users are not. Meanwhile, in the case rN, Ne(DK)=r and f=1. Thus, we prove the case where rN.

For N<r<2N, we have Ne(DK)=N. Then, for DR, we obtain that each file cannot be requested by more than two requesters. Thus, due to a total of K users, there are 2Nr users, each of which are the only users requesting a file while each of the remaining K+r2N users are not. Meanwhile, in this case, f=0. Thus, we prove the case where N<r<2N.

Appendix A.3. Example

To aid in better understanding, we provide an example to illustrate the adapted YWSC scheme in Appendix A.1.

Let us consider a case where N=2,K=4,andM=1. Hence, t=KM/N=2. In the placement phase, each file is divided into 42=6 sub-files, and each sub-file’s index is in T, where T is the family of all sets 𝒯 such that 𝒯[4],|𝒯|=2. The user k[6] caches the following sub-files for each n{1,2}:

Zk={Wn,𝒯|𝒯T,k𝒯}.

In the delivery phase, without a loss of generality, we only consider Users 1and2, as requesters, each requesting a single file, i.e., R={1,2}, and the request vector is D{1,2}=(1,2). Hence, we consider that the request vector after adaption is D{1,2,3,4}=(1,2,1,1). Notice that r=4 and Ne(D{1,2,3,4})=2. Requesters 1and2 need the following missing sub-files:

W1Z1={W1,{2,3},W1,{2,4},W1,{3,4}},W2Z2={W2,{1,3},W2,{1,4},W2,{3,4}}.

In Step (a), since t=2, we split the sub-files into two equal-length sub-pieces. Further, determining the leading demanders from the requesters as much as possible, without a loss of generality, we assume that User 1 picks Users 1and3, User 2 picks User 1, User 3 picks Users 1and2, and User 4 picks Users 1and2 as the leading demanders, i.e., U1¯={2,3},U2¯={1},U3¯={1,2},andU4¯={1,2}. Notice that Ne(DK{1})=2,Ne(DK{2})=1,Ne(DK{3})=2,andNe(DK{4})=2.

In Step (b), for User 1, E1 is of size t=2 and is a subset of K{1}={2,3,4}. Hence, possible E1s can be {2,3},{2,4},and{3,4}, which all satisfy the condition of non-zero intersection with U1¯={2,3}. Hence, from (22) and (23), User 1 pre-transmits

Y{2,3}1=W2,{1,3},1W1,{1,2},1,Y{2,4}1=W2,{1,4},1W1,{1,2},1,Y{3,4}1=W1,{1,4},1W1,{1,3},1.

Similarly, User 3 pre-transmits

Y{1,2}3=W1,{2,3},3W2,{1,3},3,Y{1,4}3=W1,{3,4},3W1,{1,3},3,Y{2,4}3=W2,{3,4},3W1,{2,3},3,

and User 4 pre-transmits

Y{1,2}4=W1,{2,4},4W2,{1,4},4,Y{1,3}4=W1,{3,4},4W1,{1,4},4,Y{2,3}4=W2,{3,4},4W1,{2,4},4.

As for User 2, E2 is of size t=2 and is a subset of K{2}={1,3,4}. Hence, possible E2s can be {1,3},{1,4},and{3,4}. Recall that U2¯={1}; hence, only {1,3} and {1,4} satisfy the condition of non-zero intersection with U2={1}. Hence, from (A2) and (A3), User 2 pre-transmits

Y{1,3}2=W1,{2,3},2W1,{1,2},2,Y{1,4}2=W1,{2,4},2W1,{1,2},2.

The signal Y{3,4}2=W1,{2,3},2W1,{2,4},2 does not need to be pre-transmitted and can be calculated since Y{1,3}2Y{1,4}2Y{3,4}2=0 (cf. (24)).

In Step (c), removing unwanted codewords, we notice that the codeword Y{3,4}1 is only useful for the users, who do not request, and hence are removed. The other codewords are transmitted in the way of Step (b).

Thus, the total delivery rate achieved by the adapted YWSC scheme for the case R={1,2} and D{1,2,3,4}=(1,2,1,1) is Radapted-YWSC{1,2}=2+3+3+212=56, which coincides with (A1). In this case, if we directly use the YWSC scheme [9] by assigning Users 3 and 4 a demand that is the same as User 1, then according to [9] (Equation (14)), the delivery rate is 4×3112=1112. If we assign Users 3 and 4 with some other demands, the delivery rate will be the same. However, if we use the proposed three-category-based scheme from Section 4.1, then according to (A1), the delivery rate is Rreq-rob{1,2}=23. Hence, we see that for the request-robust D2D coded caching problem, the proposed three-category-based scheme performs better than the adapted YWSC scheme for this example.

The reason why the proposed three-category-based scheme and the adapted YWSC scheme have better performance is in the following remark:

Remark A1.

The achievable rate Radapted-YWSCDR of our model is similar to the achievable rate R*(d,MMAN) of Yapar’s model [9]. The main difference is that the value of Ne(d{i}) in R*(d,MMAN) depends on all the users’ request vector d, while the value of Ne(DK{i}) in Radapted-YWSCDR depends on the r requesters’ request vector DR. When N,K,andM is the same, for User i, there is Ne(DK{i})Ne(d{i}), and hence Radapted-YWSCDRR*(d,MMAN) for uniform demand distribution and the worst case. However, using the adapted YWSC scheme, the signal Xiadapted-YWSC may contain useless information. For example, in Appendix A.3, the signal Y{2,3}1 contains the useless sub-piece W1,{1,2},1, which is transmitted for User 3, who does not request. We find that removing useless sub-pieces does not affect the size of the rate but makes signals contain too small uncoded sub-pieces. The proposed three-category-based scheme in Section 4 does not contain useless information and maximizes the global gain brought from the code by utilizing the users, who do not request, to transmit signals as much as possible.

Appendix B. Proof of Theorem 3

Appendix B.1. The Maximum Average Delivery Rate

In this subsection, we propose the converse bound given in Theorem 3 for the maximum average delivery rate of the request-robust D2D coded caching problem. Let us consider the problem of coded caching with inactive users defined in Section 2.2.2 first. For a problem of coded caching with inactive users with the rate Rinact, given the same placement Z and requester demand vector DR as in Section 2.1, the encoding function on the central server is

ϕDR:[2NF][2RinactF],

and the delivery information X is denoted as X=ϕDR(W1,,WN). The r requesters decode the request message according to caching content and delivery information, and the decoding function is defined as

ψkDR:[2MkF]×[2RinactF][2F],kR.

The file decoded by User k is denoted as W^dk=ψkDR(X,Zk). If the error probability of this system satisfies

P(W^dkWdk)ϵ,

we call the system ϵ-achievable.

Given DR and Z, we define the minimum achievable rate of the ϵ-achievable system as Rϵ,inactDR*(Z). For a fixed R with size r, DR is defined as the set of all possible demands {1,,N}r. When DR is uniformly distributed on DR, given placement Z, the average delivery rate with respect to the uniform demand Rϵ,ave,inactR*(Z) is defined as

Rϵ,ave,inactR*(Z)=EDR[Rϵ,inactDR*(Z)].

For a given r, we define the maximum average delivery rate with respect to the uniform demand, denoted as Rave,inactr, where the maximum is over all the request sets R with size r. Then, the optimal maximum average delivery rate of the memory–rate tradeoff is essentially the maximum average delivery rate for the minimum value given an arbitrary cache size M, and at this rate, the user can decode the requested file with a sufficiently large size without error; that is,

Rave,inactr*=supϵ>0limsupF+minZmaxR:|R|=rRϵ,ave,inactR*(Z).

Similarly, for a fixed R with size r, given placement Z, the worst-case delivery rate is

Rϵ,worst,inactR*(Z)=maxDRRϵ,inactDR*(Z),

and for a given r, the optimal maximum worst-case delivery rate we want to find is

Rworst,inactr*=supϵ>0limsupF+minZmaxR:|R|=rRϵ,worst,inactR*(Z).

For the problem of coded caching with inactive users, we have the following results:

Theorem A1.

For the problem of coded caching with inactive users with K users, a database of N files, uncoded cache sizes of M files at each user, only r users as requesters demanding files during the delivery phase, and parameter t=KMN, we have

Rave,inactr*=EDRKt+1KNe(DR)t+1Kt, (A4)

for tK, where DR is uniformly random on DR={1,...,N}r and Ne(DR) denotes the number of distinct requests in DR. When tK, Rave,inactr* equals the lower convex envelope of the values in (A4) for integer values of tK.

Moreover, for the worst-case rate, we have

Rworst,inactr*=Kt+1Kmin{r,N}t+1Kt, (A5)

for tK. When tK, Rworst,inactr* equals the lower convex envelope of the values in (A5) for integer values of tK.

Proof. 

The tight lower bounds of the average delivery rate and worst-case delivery rate are derived in the rest of this section. The caching and delivery scheme that achieves the optimal maximum average and worst-case rates is described in Appendix C. □

Due to inequality (4), to prove Theorem 3, we just need to prove Theorem A1. Motivated by [11], to lower bound the achievable average rate, we first introduce the concept of demand-type division. For the problem of coded caching with inactive users with the number of initial users K, the number of requesters r, and the fixed request set R, given the request vector DR, we define sR(DR) as its statistics such that the ith element of sR(DR) is equal to the number of the i-th most requested file. For example, when K=6andN=4, and during the delivery phase r=4,R={1,2,3,4},andDR={1,1,3,4}, the statistic for DR is s{1,2,3,4}(DR)=(2,1,1,0). For convenience, we simply the statistics sR(DR) as sR. Then, we denote the set of all possible statistics by SR. Through this statistical method, the set of request vectors DR can be divided into some subsets as type, and type DsR is defined as the set of queries with statistics sR.

Note that for each request vector DR, the value of Ne(DR) only depends on its statistic sR(DR), so for the same type of request vector, the rate is the same. For convenience, the Ne(DR) of the type DsR is called Ne(sR).

Given the number of requesters r, the request set R, and the placement Z, for each type DsR in the problem of coded caching with inactive users, the average delivery rate Rϵ,ave,inactsR*(Z) is defined as

Rϵ,ave,inactsR*(Z)=1|DsR|DRDsRRϵ,inactDR*(Z),

For all types of request vectors, we have

Rave,inactr*=supϵ>0limsupF+minZmaxR:|R|=rEsRRϵ,ave,inactsR*(Z)supϵ>0limsupF+maxR:|R|=rEsRminZRϵ,ave,inactsR*(Z). (A6)

Hence, the lower bound of Rave,inactr* can be derived through bounding the minimum value of Rϵ,ave,inactsR*(Z) for each type DsR individually. We use the following lemma to lower bound the average rates within each type:

Lemma A1.

Consider the problem of coded caching with inactive users with K initial users, N files, MF cache sizes, r requesters, and request set R during the delivery phase; for each type DsR, the minimum value of Rϵ,ave,inactsR*(Z) is lower bounded by

minZRϵ,ave,inactsR*(Z)ConvKt+1KNe(sR)t+1Kt1F+Ne2(sR)ϵ, (A7)

where Conv(f(t)) denotes the lower convex envelope of the following points: {(t,f(t))|t{0,1,...,K}}.

Proof. 

We notice that solving the fundamental limits of the problem of coded caching with inactive users is essentially the caching problem defined in [11]. The only difference between the problem of coded caching with inactive users and the caching problem defined in [11] is the size of the request vector. Therefore, applying [11] (Lemma 2) and replacing the caching problem parameters demand d; statistics of demand s; set of all possible statistics S; set of all possible demands D; and type of demand Ds with DR,sR(DR),SR,DR,andDsR, we obtain (A7). □

From (A6) and Lemma A1, the lower bound of Rave,inactr* can be further derived as

Rave,inactr*EsRConvKt+1KNe(sR)t+1Kt. (A8)

Because the sequence

cn=Kn+1KNe(sR)n+1Kn,

is convex, the order of the expectation and the Conv in (A8) can be switched. Therefore, Rave,inactr* is lower bounded by the rate defined in Theorem A1, which immediately proves Theorem 3 for the maximum average delivery rate.

Appendix B.2. The Maximum Worst-Case Delivery Rate

Due to (5), to prove Theorem 3 for the maximum worst-case delivery rate, we just need to prove Theorem A1 for the maximum worst-case delivery rate. Given the number of requesters r, the request set R, and placement Z, for each type DsR in the problem of coded caching with inactive users, we define the worst-case delivery rate Rϵ,worst,inactsR*(Z) as

Rϵ,worst,inactsR*(Z)=maxDRDsRRϵ,inactDR*(Z).

Note that

Rworst,inactr*=supϵ>0limsupF+minZmaxR:|R|=rmaxsRRϵ,worst,inactsR*(Z)supϵ>0limsupF+maxR:|R|=rmaxsRminZRϵ,worst,inactsR*(Z).

For each sRSR, using Lemma A1, we can know that

minZRϵ,worst,inactsR*(Z)minZRϵ,ave,inactsR*(Z)ConvKt+1KNe(sR)t+1Kt1F+Ne2(sR)ϵ.

When N,K,M,r,andR do not change, since the worst-case delivery rate Rϵ,worst,inactsR*(Z) decreases as Ne(sR) decreases, the optimal worst-case delivery rate is the one at the maximum value of Ne(sR). Meanwhile, there is

Ne(sR)min{r,N}. (A9)

Consequently,

Rworst,inactr*supϵ>0limsupF+maxR:|R|=rmaxsRConvKt+1KNe(sR)t+1Kt1F+Ne2(sR)ϵ=ConvKt+1Kmin{r,N}t+1Kt.

Therefore, Rworst,inactr* is lower bounded by the rate defined in Theorem A1 for the maximum worst-case delivery rate, which immediately proves Theorem 3 for the maximum worst-case delivery rate.

Appendix C. Optimal Scheme for Problem of Coded Caching with Inactive Users Achieved in Theorem A1

In this section, we present the optimal scheme for the problem of coded caching with inactive users. The scheme achieves the rate stated in Theorem A1. We will characterize the performance of the proposed scheme and show that for any requester set R and corresponding request vector DR, the optimal scheme achieves the rate

Rinact=Kt+1KNe(DR)t+1Kt. (A10)

The rate Rinact with the explicit characterization of the maximum worst-case delivery rate in (A9) immediately proves Theorem A1.

Similar to Section 4.1, we restrict to integer values of tK and use the MAN uncoded symmetric placement scheme given in Definition 1 in the placement phase. For non-integer values of t, the pair (M,Rinact) achieves the lower convex envelope of the achievable points for integer values of tK.

For the delivery phase, the central server arbitrarily selects a subset of Ne(DR) requesters, denoted by U^={u^1,,u^Ne(DR)}, that requests Ne(DR) distinct files, U^R. Following the idea of leaders from [11], we name these requesters as leaders.

Given an arbitrary subset H of t+1 users, each requester kHR needs the sub-file Wdk,H{k}, which is known by all other users in H. Precisely, all the requesters kHR shall retrieve the needed sub-files Wdk,H{k} from the transmissions of the central server. By letting the central server broadcast the codeword

YH=xHRWdx,H{x},whereHR, (A11)

this sub-file retrieval can be accomplished since each requester kHR has all the sub-files on the RHS of (A11) except for Wdk,H{k}.

In order to achieve the rate in (A10), the central server only needs to transmit the codeword YH, which is useful for at least one leader, i.e., Xinact={YH}HU^. The above delivery scheme totally transmits Kt+1KNe(DR)t+1 codewords each with a size of F/Kt bits, which achieves the rate in (A10).

Remark A2.

We notice that the proposed scheme is in fact the shared-link model [3] with the same file number N, file size F, user number K, cache size M, and corresponding parameter t. The only difference is the size of the request vector. Replacing the shared-link system parameter Ne(d) in (19) with Ne(DR), we obtain (A10).

We now prove that each requester can decode the file requested by the above delivery scheme. When k is a leader, i.e., kU^, it can decode any required sub-file Wdk,H, where Hk,|H|=t, from YH{k} by performing

Wdk,H=xHWdx,H{k}{x}YH{k}, (A12)

where YH{k} is defined in (A11).

When kRU^, not all codewords YH{k} are transmitted, and the requester k needs to decode the required codewords not transmitted directly. We use Lemma A2 to explain that the non-leader requester k can also decode all the required sub-files, even if the central server does not transmit YH{k}, where HU^=.

Lemma A2.

Given the request vector DR and picking a set of leaders U^, for any set IK, let VF be the family of all subsets V of I such that each requested file in DR is requested by exactly one user in V, and we have

VVFYIV=0, (A13)

where YIV is defined in (A11).

Proof. 

As mentioned in Remark A2, the proposed scheme for the problem of coded caching with inactive users is actually the shared-link scheme. Thus, Lemma 1 in [11] can be directly applied to the proposed scheme. □

Consider any subset H of t+1 non-leader users but containing requesters. From Lemma A2, the codeword YH can be directly computed from the transmitted codewords by using the following equation:

YH=VVF{U^}YIV, (A14)

where I=HU^, given the fact that all codewords on the RHS of (A14) are broadcast, because each IV has a size of t+1 and contains at least one leader. Hence, each requester k can obtain the value YH for any subset H, where HR of t+1 users, and can decode its demanded files as discussed in (A11). The proposed scheme for the problem of coded caching with inactive users achieves the rate in (A10), which proves the achievability of Theorem A1.

For the convenience of understanding, we give the algorithm of the caching and delivery scheme with inactive users in Algorithm A2.

Algorithm A2 Caching and Delivery Scheme with Inactive Users (N,K,M)
  • procedure 

    PLACEMENT (W1,,WN)

  •   1:

    Apply Algorithm 1 MAN Uncoded Symmetric Placement Scheme (N,K,M,W[N])

  • end procedure 

     

  • procedure 

    DELIVERY (R,DR)

  •   2:

    tKM/N

  •   3:

    Ne(DR) the number of distinct elements in DR

  •   4:

    U^{u^1,...,u^Ne(DR)}

  •   5:

    for  H[K]:|H|=t+1  do

  •   6:

    if  HU^==  then

  •   7:

      continue

  •   8:

    else

  •   9:

      Central server transmits YH=xH:dxDRWdx,H{x}

  • 10:

    end if

  • 11:

    end for

  • end procedure 

     

We provide an example to explain how the proposed scheme works.

Let us consider a case that N=2,K=3,M=2/3,andt=KM/N=1. In the placement phase, each file is divided into 31=3 sub-files. The users k[3] cache the following sub-files:

Z1={W1,{1},W2,{1}},Z2={W1,{2},W2,{2}},Z3={W1,{3},W2,{3}}.

In the delivery phase, only User 1and2 as requesters request a single file, i.e., R={1,2}, and the request vector is D{1,2}=(1,1). Notice that r=2 and Ne(D{1,2})=1.

Without a loss of generality, assume that the central server picks User 1 as the leader, i.e., U^={1}. Then, the central server transmits the following codewords:

Y{1,2}=W1,{2}W1,{1},Y{1,3}=W1,{3},

without transmitting Y{2,3}=W1,{3}, this will cause Y{2,3}Y{1,3}=0 from (A13). No matter what the leader central server picks, it can transmit one less codeword, denoted as YH, where HU^=, through this method.

From the transmitted codewords just mentioned, all the requesters can decode all their needed files by performing (A12). The rate Rinact=1/3×2=2/3 and could be directly calculated by (A10).

Remark A3.

The proposed scheme for the problem of coded caching with inactive users is with secure delivery [28] for t1 and r2, where the users who do not request and the external wiretapper cannot decode any files since the transmitted codewords only consist of the sub-files needed by requesters, and the sub-files whose index only consists of requesters would not be directly transmitted and cannot be decoded.

Appendix D. Order Optimality of the Adapted YWSC Scheme in Appendix Section A.1 i.e., Proof of Theorem 4

As discussed in Remark 1, in this section, under the constraint of the uncoded cache placement, we only compare the achievable rate Radapted-YWSCDR from (A1) with the lower bound rate for Rave,req-robr* and Rworst,req-robr* from (12) and (13), respectively.

For the maximum average delivery rate, from (12), (A4), and (A10), we have that EDR[Radapted-YWSCDR]Rave,req-robr*Rave,inactr*=EDR[Rinact]. Furthermore, we observe that Rinacttt+1Radapted-YWSCDR by the following:

tt+1Radapted-YWSCDR1t+1KK1t1t+1i=1KK1Ne(DK{i})tKt=Kt+1i=1K1KNe(DK{i})KNe(DK{i})t+1KtKt+1miniKKNe(DK{i})KNe(DK{i})t+1KtKt+1KNe(DR)t+1Kt=Rinact, (A15)

where (A15) is because 1Ne(DR{i})Ne(DK{i})Ne(DK)=Ne(DR) for all i[K].

Therefore, we have that

EDR[Radapted-YWSCDR]Rave,req-robr*Rave,inactr*=EDR[Rinact]tt+1EDR[Radapted-YWSCDR]12EDR[Radapted-YWSCDR].

gives the same result, which is

maxDRRadapted-YWSCDRRworst,req-robr*Rworst,inactr*=maxDRRinacttt+1maxDRRadapted-YWSCDR12maxDRRadapted-YWSCDR,

which can be achieved for the maximum worst-case delivery rate by using similar steps. These results prove that the achievable rate Radapted-YWSCDR is order optimal within a factor of two under the constraint of uncoded cache placement. In addition, by the proved order optimality of the shared-link scheme within a factor of two [29] for allowing coded placement, and as discussed in Remark A2 that the only difference between the delivery scheme with inactive users and a shared-link scheme is the size of the request vector, it immediately proves that the achieved rate is within a factor of four in general and completes the proof of Theorem 4.

Author Contributions

Conceptualization, W.W., Z.T., N.L. and W.K.; methodology, W.W., Z.T., N.L. and W.K.; formal analysis, W.W., Z.T., N.L. and W.K.; writing—original draft preparation, W.W.; writing—review and editing, W.W., N.L. and W.K.; supervision, N.L. and W.K.; funding acquisition, N.L. and W.K. All authors have read and agreed to the published version of the manuscript.

Institutional Review Board Statement

Not applicable.

Data Availability Statement

Data are contained within the article.

Conflicts of Interest

Author Zhe Tao was employed by the company Huawei Technologies. The author declares that the research was conducted in the absence of any commercial or financial relationships that could be construed as a potential conflict of interest. The funders had no role in the design of the study; in the collection, analyses, or interpretation of the data; in the writing of the manuscript; or in the decision to publish the results.

Funding Statement

This work is partially supported by the National Natural Science Foundation of China under Grants 62361146853, 62071115, and 62371129 and the Research Fund of the National Mobile Communications Research Laboratory, Southeast University (no. 2024A03).

Footnotes

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

References

  • 1.Akpakwu G.A., Silva B.J., Hancke G.P., Abu-Mahfouz A.M. A Survey on 5G Networks for the Internet of Things: Communication Technologies and Challenges. IEEE Access. 2018;6:3619–3647. doi: 10.1109/ACCESS.2017.2779844. [DOI] [Google Scholar]
  • 2.Golrezaei N., Molisch A.F., Dimakis A.G., Caire G. Femtocaching and device-to-device collaboration: A new architecture for wireless video distribution. IEEE Commun. Mag. 2013;51:142–149. doi: 10.1109/MCOM.2013.6495773. [DOI] [Google Scholar]
  • 3.Maddah-Ali M.A., Niesen U. Fundamental Limits of Caching. IEEE Trans. Inf. Theory. 2014;60:2856–2867. doi: 10.1109/TIT.2014.2306938. [DOI] [Google Scholar]
  • 4.Wei Q., Wang L., Xu L., Tian Z., Han Z. Hierarchical Coded Caching for Multiscale Content Sharing in Heterogeneous Vehicular Networks. IEEE Trans. Veh. Technol. 2022;71:5770–5786. doi: 10.1109/TVT.2022.3158363. [DOI] [Google Scholar]
  • 5.Maddah-Ali M.A., Niesen U. Decentralized Coded Caching Attains Order-Optimal Memory-Rate Tradeoff. IEEE/ACM Trans. Netw. 2015;23:1029–1040. doi: 10.1109/TNET.2014.2317316. [DOI] [Google Scholar]
  • 6.Cheng H., Li C., Xiong H., Frossard P. Optimal decentralized coded caching for heterogeneous files; Proceedings of the 2017 25th European Signal Processing Conference (EUSIPCO); Kos, Greece. 28 August–2 September 2017; pp. 2531–2535. [DOI] [Google Scholar]
  • 7.Zheng L., Chen Q., Yan Q., Tang X. Decentralized Coded Caching Scheme With Heterogeneous File Sizes. IEEE Trans. Veh. Technol. 2020;69:818–827. doi: 10.1109/TVT.2019.2949979. [DOI] [Google Scholar]
  • 8.Ji M., Caire G., Molisch A.F. Fundamental Limits of Caching in Wireless D2D Networks. IEEE Trans. Inf. Theory. 2016;62:849–869. doi: 10.1109/TIT.2015.2504556. [DOI] [Google Scholar]
  • 9.Yapar C., Wan K., Schaefer R.F., Caire G. On the Optimality of D2D Coded Caching With Uncoded Cache Placement and One-Shot Delivery. IEEE Trans. Commun. 2019;67:8179–8192. doi: 10.1109/TCOMM.2019.2940671. [DOI] [Google Scholar]
  • 10.Wang W., Liu N., Kang W. Three-User D2D Coded Caching With Two Random Requesters and One Sender. IEEE Trans. Commun. 2023;71:6967–6978. doi: 10.1109/TCOMM.2023.3310506. [DOI] [Google Scholar]
  • 11.Yu Q., Maddah-Ali M.A., Avestimehr A.S. The Exact Rate-Memory Tradeoff for Caching With Uncoded Prefetching. IEEE Trans. Inf. Theory. 2018;64:1281–1296. doi: 10.1109/TIT.2017.2785237. [DOI] [Google Scholar]
  • 12.Wan K., Sun H., Ji M., Tuninetti D., Caire G. On the Fundamental Limits of Device-to-Device Private Caching under Uncoded Cache Placement and User Collusion. IEEE Trans. Inf. Theory. 2022;68:5701–5729. doi: 10.1109/TIT.2022.3173581. [DOI] [Google Scholar]
  • 13.Wan K., Sun H., Ji M., Tuninetti D., Caire G. Device-to-Device Private Caching with Trusted Server; Proceedings of the ICC 2020–2020 IEEE International Conference on Communications (ICC); Dublin, Ireland. 7–11 June 2020; pp. 1–6. [DOI] [Google Scholar]
  • 14.Wan K., Sun H., Ji M., Tuninetti D., Caire G. Novel Converse for Device-to-Device Demand-Private Caching with a Trusted Server; Proceedings of the 2020 IEEE International Symposium on Information Theory (ISIT); Los Angeles, CA, USA. 21–26 June 2020; pp. 1705–1710. [DOI] [Google Scholar]
  • 15.Ibrahim A.M., Zewail A.A., Yener A. Device-to-Device Coded-Caching With Distinct Cache Sizes. IEEE Trans. Commun. 2020;68:2748–2762. doi: 10.1109/TCOMM.2020.2970950. [DOI] [Google Scholar]
  • 16.Woolsey N., Chen R.R., Ji M. Towards Finite File Packetizations in Wireless Device-to-Device Caching Networks. IEEE Trans. Commun. 2020;68:5283–5298. doi: 10.1109/TCOMM.2020.3006897. [DOI] [Google Scholar]
  • 17.Zhang X., Ji M. Finite-length Analysis of D2D Coded Caching via Exploiting Asymmetry in Delivery; Proceedings of the 2022 IEEE 23rd International Workshop on Signal Processing Advances in Wireless Communication (SPAWC); Oulu, Finland. 4–6 July 2022; pp. 1–5. [DOI] [Google Scholar]
  • 18.Zewail A.A., Yener A. Device-to-Device Secure Coded Caching. IEEE Trans. Inf. Forensics Secur. 2020;15:1513–1524. doi: 10.1109/TIFS.2019.2940885. [DOI] [Google Scholar]
  • 19.Awan Z.H., Sezgin A. Fundamental limits of caching in D2D networks with secure delivery; Proceedings of the 2015 IEEE International Conference on Communication Workshop (ICCW); London, UK. 8–12 June 2015; pp. 464–469. [DOI] [Google Scholar]
  • 20.Ji M., Chen R.R., Caire G., Molisch A.F. Fundamental limits of distributed caching in multihop D2D wireless networks; Proceedings of the 2017 IEEE International Symposium on Information Theory (ISIT); Aachen, Germany. 25–30 June 2017; pp. 2950–2954. [DOI] [Google Scholar]
  • 21.Lee M.C., Ji M., Molisch A.F. Optimal Throughput-Outage Analysis of Cache-Aided Wireless Multi-Hop D2D Networks. IEEE Trans. Commun. 2021;69:2489–2504. doi: 10.1109/TCOMM.2020.3045787. [DOI] [Google Scholar]
  • 22.Tebbi A., Sung C.W. Coded caching in partially cooperative D2D communication networks; Proceedings of the 2017 9th International Congress on Ultra Modern Telecommunications and Control Systems and Workshops (ICUMT); Munich, Germany. 6–8 November 2017; pp. 148–153. [DOI] [Google Scholar]
  • 23.Phatak A., Varanasi M.K. An improved coded caching scheme for partially cooperative D2D networks; Proceedings of the 2022 IEEE International Symposium on Information Theory (ISIT); Espoo, Finland. 26 June–1 July 2022; pp. 1121–1126. [DOI] [Google Scholar]
  • 24.Li J., Chang Y. New Constructions of D2D Placement Delivery Arrays. IEEE Commun. Lett. 2023;27:85–89. doi: 10.1109/LCOMM.2022.3212679. [DOI] [Google Scholar]
  • 25.Wang W., Liu N., Kang W. Coded Caching in Request-robust D2D Communication Networks; Proceedings of the 2023 International Symposium on Networks, Computers and Communications (ISNCC); Doha, Qatar. 23–26 October 2023; pp. 1–6. [DOI] [Google Scholar]
  • 26.Liao J., Tirkkonen O. Coded Caching in Presence of User Inactivity; Proceedings of the 2022 IEEE Wireless Communications and Networking Conference (WCNC); Austin, TX, USA. 10–13 April 2022; pp. 1437–1442. [DOI] [Google Scholar]
  • 27.Wan K., Tuninetti D., Piantanida P. On the optimality of uncoded cache placement; Proceedings of the 2016 IEEE Information Theory Workshop (ITW); Cambridge, UK. 11–14 September 2016; pp. 161–165. [DOI] [Google Scholar]
  • 28.Sengupta A., Tandon R., Clancy T.C. Fundamental Limits of Caching With Secure Delivery. IEEE Trans. Inf. Forensics Secur. 2015;10:355–370. doi: 10.1109/TIFS.2014.2375553. [DOI] [Google Scholar]
  • 29.Yu Q., Maddah-Ali M.A., Avestimehr A.S. Characterizing the Rate-Memory Tradeoff in Cache Networks Within a Factor of 2. IEEE Trans. Inf. Theory. 2019;65:647–663. doi: 10.1109/TIT.2018.2870566. [DOI] [Google Scholar]

Associated Data

This section collects any data citations, data availability statements, or supplementary materials included in this article.

Data Availability Statement

Data are contained within the article.


Articles from Entropy are provided here courtesy of Multidisciplinary Digital Publishing Institute (MDPI)

RESOURCES