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

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.


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 begin-ning 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.

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.

Notations
Throughout this paper, H(•) represents the entropy of random variables, | • | represents the cardinality of a set, ⊕ denotes finite field addition, we let For two integers x, and y, if x < y or x ≤ 0, we let ( y x ) = 0.

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 △ = (W 1 , ..., W N ).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 M ≤ N. Let K be the set of user indices, i.e., K △ = [K].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 Z k , k ∈ K.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, R ⊆ K.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 which map the N files into cache contents of the users, denoted by Z k = φ k (W 1 , ..., W N ), k ∈ K. Thus, we have the following entropy constraint: where D R 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} = (d 2 , d 4 ).The encoding function ϕ D R k denotes the mapping of User k from its cached content to the signal it transmits, which is denoted as We assume the signal 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 Ŵd 2 = ψ ) and Ŵd 4 = ψ ), respectively.

Correct decoding by the users requesting files is given by Ŵd
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., which implies that we are interested in the case where KM ≥ N.
For any caching and delivery scheme that satisfies the decodability constraint, for a fixed R with size r, we define D R 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 D R is uniformly distributed on D R .Then, the average delivery rate with respect to the uniform demand R R ave,req-rob is defined as For a given r, we define the maximum average delivery rate with respect to the uniform demand R r ave,req-rob , where the maximum is over all request sets R with size r, i.e., R r ave,req-rob = max The worst-case performance is defined as follows: first, the worst-case delivery rate R R worst,req-rob is defined as For a given r, we define the maximum worst-case delivery rate R r worst,req-rob , where the maximum is over all request sets R with size r, i.e.,

R r
worst,req-rob = max We would like to design caching and delivery schemes such that R r ave,req-rob and R r worst,req-rob 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 N e (D R ) as the number of distinct files in a request vector D R .D R\{k} and N e (D R\{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.

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.

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 W n is divided into ( K t ) disjoint sub-files denoted by W n,T , where n ∈ [N], T ⊆ K, |T | = t, and H(W n,T ) = F/( K t ).Each user k caches all the bits of the sub-files W n,T , n ∈ [N], for all T ∋ k.Since each file includes ( K−1 t−1 ) sub-files with T ∋ k, each user k satisfies the memory constraint H For the convenience of understanding and reference, we give the algorithm of this scheme in Algorithm 1.
Divide file W n into disjoint sub-files (W n,T : T ∈ T) with equal size 5: end for 6: for k ∈ [K] do 7: 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.

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 K − 1 users, the optimal maximum average and worst-case delivery rate in System 2, denoted as R r * ave,inactive and R r * worst,inactive , can not be larger than the delivery rate in System 1, respectively.In other words, we have the following inequality: R r * worst,req-rob ≥ R r * worst,inactive . (5)

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 D ′ K and the adapted request vector of users K \ {k} as D ′ K\{k} .Hence, we have N e (D ′ K ) = N e (D R ) 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 R r * ave,req-rob when t = KM N 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., N e (D R ) = r; otherwise, f = 0.When t / ∈ [K], R r * ave,req-rob 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 R r * worst,req-rob ≤ max , otherwise, worst,req-rob 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 ave,req-rob 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 , otherwise, worst,req-rob 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: R r * ave,req-rob ave,req-rob 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 R r * worst,req-rob ≥ worst,req-rob 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.

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 D R , the proposed three-category-based scheme achieves the rate 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.

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 M MAN .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 k ∈ K \ R who does not request arbitrarily selects a subset of N e (D R ) requesters, denoted by U ′k = {u ′k 1 , ..., u ′k N e (D R ) } ⊆ R, that request N e (D R ) 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 W n,T and is cached by only users in T .If T ⊆ K \ R, 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 T contains some elements from R and some elements from K \ R, 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 T ⊆ 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 ∈ [K − r + 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, k ∈ R, since these subfiles are not cached in any of the requesters, the users in K \ R who cache these sub-files transmit them in an uncoded form.Suppose W d k ,T is requested by User k ∈ R, T ⊆ K \ R, any of the t users in T can transmit the sub-file in an uncoded form.However, we adopt the file-splitting strategy in [9] and allow each user in T to transmit 1/t part of the sub-file, i.e., W d k ,T is divided into t pieces, each consisting of numbers of bits.The pieces are denoted as W d k ,T ,a , a ∈ T , and User a transmits We notice that W d k ,T ,a may be needed by other requesters, i.e., there may be other requesters that request file d k also.Hence, we let each user a transmit in sequence X 1st,d k ,T a for all k ∈ U ′a .Hence, the rate of transmitting total bits for the sub-files in the first category is because for each T , every user a ∈ T transmits N e (D R ) F t( K t ) bits, and there are t users in each T , and a total of ( K−r t ) number of T that are subsets of K \ R. (ii) Consider a sub-file in the second category needed by Requester k, k ∈ R, denoted as W d k ,T , where k / ∈ T .Denote the set of elements in T that are in R as B, whose size is denoted as i, and we have 1 ≤ i ≤ r − 1, because we know at least User k who is requesting a file is not in T .Further denote the set of elements of T that are in K \ R as B, whose size is t − i, and we have 1 ≤ t − i ≤ K − r.Hence, T can be written as Consider the set B ≜ {k} B, which is a set consisting of i + 1 requesters.The sub-file W d x , B B\{x} is needed for x ∈ B. We ask that this sub-file be transmitted by the t − i non-requesters, and W d x , B B\{x} for any x ∈ B be divided into t − i equal-length disjoint sub-pieces of bits, which are denoted by 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 W d x , B B\{x},b .
We ask each user , 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 t − i, is ( K−r t−i ).For each u ∈ B, the number of transmitted bits is ) times the size of a sub-piece, and there are a total of t − i users in B. Hence, the rate of transmitting all the bits for the sub-files in the second category is 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 b ∈ B generates its codewords exclusively from the sub-pieces W d k , B∪B,b , and there exist ( r i ) such sub-pieces in its cache.In addition, for any c ∈ B \ {b}, we have bits.
Therefore, the proposed scheme is in fact composed of (t − i) shared-link models [3] each with N files of size F ′ = ( r i )F/( K t ) 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 ′ = K ′ M ′ N = i.To ensure the existence of sub-files in the second category, the partition integer must satisfy , summing the achievable rates R sl , which is defined as follows from [11]: of each b ∈ B shared-link sub-system and replacing the shared-link system parameters F, K, M, t, and N e (d) with F ′ , K ′ , M ′ , t ′ , andN e (D R ), respectively, we obtain (18).
We now prove that for each partition integer i ∈ [max{1, t + r − K}, min{t − 1, r − 1}], each requester k is able to decode the needed sub-files in the second category with the partition integer i upon receiving the codewords X , which is broadcast from user b by performing as can be seen from ( 17).
When k / ∈ U ′b , it is less straightforward for the non-leading requester k to decode the needed sub-files, because not all of the corresponding codewords for its required sub-pieces W d k , B∪P k ,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 ⊆ K \ R of size t − i, a user b ∈ B, and a set of leading requesters U ′b , for any subset C b ⊆ R that includes U ′b , let V b F be family of all subsets V b of C b such that each requested file in D R is requested by exactly one user in V b .The following equation holds: 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 (t − i) sharedlink 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 ∩ U ′b = ∅.Using (20), the following equation can be derived: where C b = B ′i ∪ U ′b .Equation (21) shows that the codeword X 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 F t( K t ) bits, which are denoted by W n,T ,i , i ∈ T .Further, each user i in requester set R, where |R| = r, selects an arbitrary subset of N e (D R\{i} ) users from R \ {i}, denoted by U i = {u i 1 , ..., u i N e (D R\{i} ) }, which request N e (D R\{i} )) distinct files and are referred to as leading demanders of user i.Then, for all subsets E i ⊆ R \ {i} of t users, each user i transmits where In other words, since all users k ∈ E i shall retrieve the needed sub-pieces W d k ,{E i ∪{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 Y i E i for all subsets E i such that E i ∩ U i ̸ = ∅, i.e., X 3rd i .As a result, when User k is a leading demander for User i, i.e., k ∈ U i , it can decode any needed sub-piece , which is transmitted from User i by performing When User k is not a leading demander for User i, using the equation proved in [9] (Lemma 1), where subset C i ⊆ R \ {i} includes U i and V i F denotes the family of all subsets V i of C i such that each requested file in D R\{i} is requested by exactly one user in V i , each user k can decode its requested sub-piece through obtaining the value Y i E i , for any subset E i of t users such that E i ∩ U i = ∅, from the broadcast codewords by the following equation: where C i = E i ∪ U i .To sum up, for each i ∈ R \ {k}, User k decodes its requested subpieces by following either one of the strategies above, depending on whether it is a leading demander of User i or not.
For each user i ∈ R, the size of the transmitted signal amounts to ( r−1 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 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, W n,T T ⊂ R, |T | = t , and each file has F ≜ ( r t ) F 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 F , which is equal to F ( r t ) , and sub-file W n,T is placed in users in T .Thus, each user caches a total of N( r−1 t−1 ) sub-files.Hence, each user has a memory of bits, and we can check that r M 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, and Ne(d)) in [9], which denote the file size, number of files, number of users, cache size of each user, the parameter defined as t = KMF NF , and the number of users requesting different files, respectively, we have F, N, r, M, t, and Ne(D R ) 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 which results in the rate stated in (14).The description of this subsection with the explicit characterization of the maximum worstcase 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 R R ave,req-rob and the same worst-case delivery rate R R worst,req-rob .
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) U ′k ← {u ′k 1 , ..., u ′k N e (D R ) } 7: end for 8: (i) For sub-files in the first category:  end for 57: end for end procedure

The Maximum Worst-Case Delivery Rate
In this subsection, we characterize the performance of the proposed three-categorybased scheme for the maximum worst-case delivery rate.The characterization is based on the observation that the binomial coefficient ( n m ) demonstrates a strictly ascending pattern with respect to n.
For the request-robust D2D coded caching problem, when N, K, M, r, and R do not change, since the upper bound rate R D R req-rob from ( 14) decreases as N e (D R ) decreases, the upper bound rate for the maximum worst-case delivery rate is the one at the maximum value of N e (D R ), i.e., N e (D R ) = min{r, N}. (26) Then, for r ≥ 2N, each file can be requested by at least two requesters, which leads to N e (D R\{i} ), ∀i ∈ R having the maximum value of N. Hence, this case maximizes the upper bound rate R D R req-rob .For r < 2N, a requester i may be the only user requesting a file or not, which leads to N e (D R\{i} ) = N e (D R ) − 1 and N e (D R\{i} ) = N e (D R ), respectively.Hence, due to (26), for r ≤ N, we have ( r−1−N e (D R\{i} ) t ) = 0, which proves the case where r ≤ N.For N < r < 2N, we have N e (D R ) = 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 2N − r requesters, each of which are the only users requesting a file while each of the remaining 2(r − N) requesters are not.Thus, we prove the case where N < r < 2N.

Example
To aid in better understanding, we provide an example to illustrate the proposed scheme in Section 4.1.
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 {W n,A |A ∋ {k}, k ∈ K \ R}, 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 N e (D R\{i} ) is the same for every i ∈ R, 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 W k d k (i) from its own cache and the transmission of a single other user whose index is j k (i), i.e., H(W k d k (i)|X j k (i) , Z k ) = 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 ∈ where ( 27) is from ( 8) and ( 28) is from (11).Meanwhile, when t ∈ [2, = 1 where ( 29) is from ( 8) and (30) is from (11).Moreover, t ≥ K, i.e., M ≥ N, 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.

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., R r ave,req-rob and R r worst,req-rob .We find that, in these cases, our proposed threecategory-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].  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.

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 requestrobust 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.1.General Scheme Similar to Section 4.1, for the placement phase, we still use M MAN 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 D ′ K , and the adapted request vector of users K \ {k} as D ′ K\{k} .For example, if 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 Ū i .For example, for , the leading demander of User 2 in the assumption is Ū 2 = {1} and should not be {3}, while the leading demander of User 1 is Ū 1 = {2, 3}.
(b) Pre-transmitting signals: Then, for all subset E i ⊆ K \ {i} of t users, each user i prepares for transmitting: where which is the same as (23).In other words, since all users k ∈ E i shall retrieve the needed sub-pieces W d k ,{E i ∪{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 Y i E i for all subsets E i such that E i ∩ U i ̸ = ∅, i.e., X YWSC i .(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 Y i E i where E i ∩ Ū i ̸ = ∅.For user i, when Ū i ∩ K \ R = ∅, the signal X YWSC i does not have unwanted codewords.When Ū i ∩ K \ R ̸ = ∅, the signal X YWSC i may have the codewords Y i E i where E i ⊆ K \ R, 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 Ū i ∩ K \ R ̸ = ∅ for only one requester i in R. Hence, for all subsets E i ⊆ K \ {i} of t users, each user i transmits where Y i E i is defined in (A3).As a result, when Requester k is a leading demander for User i, i.e., k ∈ U i , it can decode any needed sub-piece G k ∪{k} , which is transmitted from User i, by performing When Requester k is not a leading demander for User i, using the equation proved in [9] (Lemma 1), where subset C i ⊆ K \ {i} includes Ū i and V i F denotes the family of all subsets V i of C i such that each requested file in D ′ K\{i} is requested by exactly one user in V i , each user k can decode its requested sub-piece through obtaining the value Y i E i for any subset E i of t users such that E i ∩ Ū i = ∅ from the broadcast codewords by the following equation: where C i = E i ∪ Ū i .To sum up, for each i ∈ K \ {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 i ∈ K, the size of the transmitted signal amounts to ( K−1 t ) − ( times the size of a sub-piece.Meanwhile, if we have Ū i ∩ K \ R ̸ = ∅ for only one requester i in R, the size of the removed unwanted codewords amounts to ( K−r t ) − ( K−r−1 t ) 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. end for 23: end for end procedure and for a given r, the optimal maximum worst-case delivery rate we want to find is

Algorithm A1
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 = KM N , we have for t ∈ K, where D R is uniformly random on D R = {1, ..., N} r and N e (D R ) denotes the number of distinct requests in D R .When t / ∈ K, R r * ave,inact equals the lower convex envelope of the values in (A4) for integer values of t ∈ K.
Moreover, for the worst-case rate, we have for t ∈ K.When t / ∈ K, R r * worst,inact equals the lower convex envelope of the values in (A5) for integer values of t ∈ K.
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 D R , we define s R (D R ) as its statistics such that the i th element of s R (D R ) is equal to the number of the i-th most requested file.For example, when K = 6 and N = 4, and during the delivery phase r = 4, R = {1, 2, 3, 4}, and D R = {1, 1, 3, 4}, the statistic for D R is s {1,2,3,4} (D R ) = (2, 1, 1, 0).For convenience, we simply the statistics s R (D R ) as s R .Then, we denote the set of all possible statistics by S R .Through this statistical method, the set of request vectors D R can be divided into some subsets as type, and type D s R is defined as the set of queries with statistics s R .
Note that for each request vector D R , the value of N e (D R ) only depends on its statistic s R (D R ), so for the same type of request vector, the rate is the same.For convenience, the N e (D R ) of the type D s R is called N e (s R ).
Given the number of requesters r, the request set R, and the placement Z, for each type D s R in the problem of coded caching with inactive users, the average delivery rate R For all types of request vectors, we have Hence, the lower bound of R r * ave,inact can be derived through bounding the minimum value of R s R * ϵ,ave,inact (Z) for each type D s R 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 D s R , the minimum value of R 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 D s with D R , s R (D R ), S R , D R , and D s R , we obtain (A7).
From (A6) and Lemma A1, the lower bound of R r * ave,inact can be further derived as Because the sequence , is convex, the order of the expectation and the Conv in (A8) can be switched.Therefore, R r * ave,inact 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 D s R in the problem of coded caching with inactive users, we define the worst-case delivery rate R For each s R ∈ S R , using Lemma A1, we can know that min When N, K, M, r, and R do not change, since the worst-case delivery rate R s R * ϵ,worst,inact (Z) decreases as N e (s R ) decreases, the optimal worst-case delivery rate is the one at the maximum value of N e (s R ).Meanwhile, there is . Therefore, R r * worst,inact 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 D R , the optimal scheme achieves the rate The rate R inact 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 t ∈ K 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, R inact ) achieves the lower convex envelope of the achievable points for integer values of t ∈ K.
For the delivery phase, the central server arbitrarily selects a subset of N e (D R ) requesters, denoted by Û = { û1 , ..., ûN e (D R ) }, that requests N e (D R ) distinct files, Û ⊆ 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 k ∈ H ∩ R needs the sub-file W d k ,H\{k} , which is known by all other users in H. Precisely, all the requesters k ∈ H ∩ R shall retrieve the needed sub-files W d k ,H\{k} from the transmissions of the central server.By letting the central server broadcast the codeword this sub-file retrieval can be accomplished since each requester k ∈ H ∩ R has all the sub-files on the RHS of (A11) except for W d k ,H\{k} .
In order to achieve the rate in (A10), the central server only needs to transmit the codeword Y H , which is useful for at least one leader, i.e., X inact = {Y H } H∩ Û ̸ =∅ .The above delivery scheme totally transmits ( K t+1 ) − ( K−N e (D R ) t+1 ) codewords each with a size of F/( K t ) 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 N e (d) in (19) with N e (D R ), 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., k ∈ Û , it can decode any required sub-file W d k ,H ′ , where H ′ ̸ ∋ k, |H ′ | = t, from Y H ′ ∪{k} by performing where Y H ′ ∪{k} is defined in (A11).When k ∈ R \ Û , not all codewords Y H ′ ∪{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 Y H ′ ∪{k} , where H ′ ∩ Û = ∅.Lemma A2.Given the request vector D R and picking a set of leaders Û , for any set I ⊆ K, let V F be the family of all subsets V of I such that each requested file in D R is requested by exactly one user in V, and we have where Y I\V 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 Y H can be directly computed from the transmitted codewords by using the following equation: where I = H ∪ Û , given the fact that all codewords on the RHS of (A14) are broadcast, because each I \ V has a size of t + 1 and contains at least one leader.Hence, each requester k can obtain the value Y H for any subset H, where H ∩ R ̸ = ∅ 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. end if 11: end for end procedure

Algorithm A2
We provide an example to explain how the proposed scheme works.Let us consider a case that N = 2, K = 3, M = 2/3, and t = KM/N = 1.In the placement phase, each file is divided into ( 3 1 ) = 3 sub-files.The users k ∈ [3] cache the following sub-files: In the delivery phase, only User 1 and 2 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 N e (D {1,2} ) = 1.Without a loss of generality, assume that the central server picks User 1 as the leader, i.e., Û = {1}.Then, the central server transmits the following codewords: From the transmitted codewords just mentioned, all the requesters can decode all their needed files by performing (A12).The rate R inact = 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 t ≥ 1 and r ≥ 2, 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 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 R D R adapted-YWSC from (A1) with the lower bound rate for R r * ave,req-rob and R r * worst,req-rob from ( 12) and ( 13), respectively.For the maximum average delivery rate, from ( 12), (A4), and (A10), we have that adapted-YWSC by the following: where (A15) is because 1 ≤ N e (D R\{i} ) ≤ N e (D ′ K\{i} ) ≤ N e (D ′ K ) = N e (D R ) for all i ∈ [K].Therefore, we have that gives the same result, which is max which can be achieved for the maximum worst-case delivery rate by using similar steps.These results prove that the achievable rate R D R adapted-YWSC 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.

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.
2nd,d k , B B\{k} b for all b ∈ B. When k is a leading requester of the user b who does not request, i.e., k ∈ U ′b , it can decode any required sub-piece W d k , B∪P k ,b , where 2nd,d k , B B\{k} b 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 X 2nd,d k , B B\{k} b 9: T ← {T ⊆ [K] \ R : |T | = t} 10: for T ∈ T do 11: for n ∈ [N] do 12:Divide sub-file W n,T into t disjoint sub-pieces (W n,T ,a : a ∈ T ) with equal size 13: end for 14: for a ∈ T do 15: for s ∈ U ′a do 16: User a transmit X 1st,d s ,T a = W d s ,T ,a 17: end for 20: (ii) For sub-files in the second category: 21: for ∈ [max{1, t + r − K}, min{t − 1, r − 1}] do 22:B ← { B ⊆ [K] \ R : | B| = t − i}23: for B ∈ B do 24: for B ⊂ R : |B| = i do 25: for n ∈ [N] do 26: Divide sub-file W n,B∪ B into t − i disjoint sub-pieces (W n,B∪ B,b : b ∈ BB ⊆ R : | B| = i + 1 do 31: if B ∩ U ′b == ∅ then b transmits X 2nd,d x , B B\{x} b = x∈ BW d x , B∪ B\{x},b 35: 40: (iii) For sub-files in the third category: 41: G ← {G ⊆ [K] : |G| = t} 42: for n ∈ [N] do 43: for G ∈ G do 44: Divide sub-file W n,G into t disjoint sub-pieces (W n,G,i : i ∈ G) with equal size 45: end for 46: end for 47: for i ∈ R do 48: N e (D R\{i} ) ← the number of distinct elements in D R\{i} 49: et al. 2016 Adapted YWSC scheme with r=20 Proposed Scheme with r=20 Proposed Converse with r=20 Adapted YWSC scheme with r=5 Proposed Scheme with r=5 Proposed Converse with r=5 Converse Ji et al. 2016

Figure 2 .
Figure 2.Consider the request-robust D2D coded caching problem from Section 2.1 where N = 10 and K = 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.

then
4, 1, 1} or D ′ {1,2,3,4} = {1, 4, 4, 4}.Obviously, N e (D ′ K ) = N e (D R ) and N e (D ′ K\{k} ) ≥ N e (D R\{k} ) for each k ∈ R. 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 W n,T and is cached by only users in T .Each sub-file is divided into t equal-length disjoint subbits, which are denoted by W n,T ,i , i ∈ T .Further, each user i selects an arbitrary subset of N e (D ′ K\{i} ) users from K \ {i}, denoted by U i = {u i Adapted YWSC Scheme (N, K, M) Divide sub-file W n,G into t disjoint sub-pieces (W n,G,i : i ∈ G) with equal size E i ⊆ K \ {i} : |E i | = t users do E i ∩ Ū i == ∅ then for if {3} , without transmitting Y {2,3} = W 1,{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 Y H , where H ∩ Û = ∅, through this method.