Combination Network with Multiaccess Caching

TL;DR

This paper introduces a new caching network design that improves efficiency by allowing users to access multiple cache nodes in a combination network.

Contribution

The novelty lies in proposing a group-wise design and explicit coded caching scheme for multi-access combination networks.

Findings

A group-wise operation reduces the design complexity to an effective (Λ,L,L,Λ,M,N) instance.

An explicit coded caching scheme is constructed using array-based representations and a CPDA.

The proposed scheme approaches the converse bound as the cache ratio increases.

Abstract

In the traditional (H,r,M,N) combination network, a central server storing N files communicates with K=(Hr) users through H cache-less relays. Each user has a local cache of size M files and is connected to a distinct subset of r relays. This paper studies the (H,r,L,Λ,M,N) combination network with multi-access caching, where Λ cache nodes (each of size M files) are available and each user can access L cache nodes. We show that in the regime H≥Λ and r≥L, an achievable design can be obtained via a group-wise operation, which reduces the scheme design within each group to an effective (Λ,L,L,Λ,M,N) instance. For the case Λ=H and L=r, we further propose an explicit coded caching scheme constructed via two array-based representations (a cache-node placement array and a user-retrieve array) and a derived combinatorial placement delivery array (CPDA) based on the Maddah-Ali–Niesen (MN) placement strategy. Numerical comparisons using the user-retrievable cache ratio as the evaluation metric indicate that the proposed scheme approaches the converse bound of the traditional combination network, and the performance gap diminishes as the cache ratio increases.

Figures

Full text

1. Introduction

With the explosive growth of mobile data traffic, caching has become an effective technique to alleviate network congestion, especially during peak hours. By pre-storing part of the content at the network edge, caching not only reduces redundant transmissions but also significantly improves the user experience. Maddah-Ali and Niesen introduced the concept of coded caching for the shared-link network in [1]. This approach combines caching and network coding to create coded multicasting opportunities among users, thereby significantly reducing the delivery load during peak traffic periods.

As described in [1], the shared-link network consists of a single server with a library of N equal-length files, each of size B bits, and K users, each equipped with a local cache memory of size $[eqn]$ bits, where $[eqn]$ . The server is connected to all users through an error-free shared link. This setup is referred to as a $[eqn]$ single-input single-output (SISO) shared-link system. A coded caching scheme for such a system operates in two phases: the placement phase and the delivery phase. In the placement phase, user demands are not yet revealed, the server prefetches part of the file into the users’ caches based on the demand statistics. The main limitation in this phase is the cache memory size. In the delivery phase, each user independently requests a file from the library. Based on these demands and the cached packets, the server sends coded packets that simultaneously satisfy multiple users. The main limitation in this phase is the transmission load required to fulfill the demands. The transmission load (or simply the load) R represents the total normalized amount of transmitted data under the worst-case demand. The coded caching gain is defined as $[eqn]$ , where $[eqn]$ corresponds to the transmission load of a conventional uncoded caching scheme. The objective is to design a scheme that minimize R, or equivalently, to maximize the gain g.

The first coded caching scheme was proposed in [1], which is referred to as the MN scheme. The MN scheme employs an uncoded placement (If the packets are directly placed in each user’s cache, it is called uncoded placement. Otherwise it is called coded placement) and a coded delivery strategy, enabling each broadcast message from the server to simultaneously serve multiple users. Under the constraint of uncoded placement, the MN scheme achieves the optimal transmission load when $[eqn]$  [2], and for arbitrary user demands, an optimal scheme under the same constraint was proposed in [3] by eliminating redundant transmissions in the MN scheme.

However, the subpacketization of the MN scheme increases exponentially with the number of users K. To address the large subpacketization problem, ref. [4] introduced a combinatorial structure called the placement delivery array (PDA), which was proposed to study coded caching schemes with low subpacketization in shared-link networks. Subsequently, various coded caching schemes with lower subpacketization were proposed based on the concept of PDA, such as [4,5,6,7,8,9]. Moreover, the concept of coded caching has since been extended to a variety of network topologies, such as device-to-device (D2D) networks [10], hierarchical networks [11], multi-server linear networks [12], and combination networks [13].

Compared with the shared-link network, a more practical network setting where users communicate with the server through intermediate relays has attracted significant attention. Since analyzing relay networks with arbitrary topologies is challenging, many studies have focused on a symmetric version of this general problem, known as combination networks with end-user-caches, which was first introduced in [13]. This system consists of a single server storing N files, each of size B bits, which is connected to H relays (without cache memories) via H orthogonal links. There are $[eqn]$ users, each equipped with a cache of size $[eqn]$ bits and connected to a unique subset of r relays through r orthogonal links. This system is referred to as an $[eqn]$ combination network. The transmission load for each relay is defined as the maximum normalized transmission amount from the server to each relay over all relays and all possible demands. The objective is to design a coded caching scheme that minimizes both the transmission load and the subpacketization.

Extensive research efforts have been devoted to investigating the coded caching problem in combination networks [13,14,15,16,17,18,19]. In [13], two caching schemes were proposed for combination networks: one based on a routing strategy and the other employing Maximum Distance Separable (MDS) codes. In [14], several caching schemes were proposed based on the placement strategy of the MN scheme, and by leveraging the acyclic index coding converse together with the network topology, the authors derived the state-of-the-art tightest converse bound under uncoded placement. In [15], a more general combination network was investigated, where both relays and users are equipped with cache memories (when the cache size of each relay is zero, the system model in [15] is the same as the traditional combination network model). The authors proposed a coded caching scheme that partitions the combination network into H independent shared-link networks and applied existing achievable schemes for the shared-link network. Ref. [17] further improved the coded placement strategy in [15] by introducing an asymmetric coded placement design, which exploits the topological symmetry to generate and deliver multicast messages, as further discussed in [16].

All the aforementioned schemes have extremely high subpacketization, which leads to high implementation complexity. To address this issue, the authors in [18] introduced the combinatorial placement delivery array (CPDA), and a low-subpacketization scheme was then proposed under the constraint that r divides H (denoted by $[eqn]$ ). Subsequently, ref. [19] presented improved CPDA constructions that eliminated the restriction $[eqn]$ .

Existing studies on combination networks have primarily focused on the conventional setting, where each user is equipped with an independent local cache and is connected to a fixed subset of relay nodes. In this model, caching is performed exclusively at the user side, while the relay nodes serve only as forwarding entities without storage capabilities.

Motivated by emerging edge caching architectures in which users may access shared cache resources deployed at the network edge (e.g., access points or edge servers), we consider a general variant of the combination network with multi-access caching, referred to as the $[eqn]$ combination network with multi-access caching. In this setting, users no longer possess individual local caches; instead, each user can access shared cache nodes deployed at the network edge. As illustrated in Figure 1, the system consists of a single server storing a library of N files, each of size B bits, which is connected to H cache-less relays through H orthogonal, error-free links. There are $[eqn]$ cache-less users in the network, each associated with a distinct subset of r relay indices and connected to the corresponding relays via r orthogonal, error-free links. At the network edge, $[eqn]$ cache nodes (also referred to as edge nodes) are deployed, each with a storage capacity of $[eqn]$ bits, where $[eqn]$ . Each user can access any L cache nodes, retrieve cached contents from these nodes without any cost, and receive server transmissions through the connected relays. The objective is to design a coded caching scheme that minimizes both the worst-case normalized transmission load over the server-to-relay links and the subpacketization.

Our main contributions are summarized as follows.

We introduce two combinatorial structures, termed the cache-node placement array and the user-retrieve array, to characterize cache placement and packet retrievability under multi-access caching.For $[eqn]$ and $[eqn]$ , we reduce the scheme design to an effective $[eqn]$ instance via a group-wise operation; for $[eqn]$ and $[eqn]$ , we further construct the proposed arrays and derive a CPDA based on the Maddah-Ali–Niesen (MN) placement strategy, yielding a coded caching scheme.We analyze the transmission load of the proposed scheme and provide numerical comparisons with the converse bound of the traditional combination network. The results show that, when evaluated with respect to the user-retrievable cache ratio, the performance gap to the converse bound diminishes as the cache ratio increases.

Notation: In this paper, we use the following notations. Bold capital letters and curlicue letters denote arrays and sets, respectively; $[eqn]$ denotes the cardinality of a set A; define $[eqn]$ , and  $[eqn]$ . For any array $[eqn]$ , $[eqn]$ denotes the entry in the $[eqn]$ row and the $[eqn]$ column. We denote $[eqn]$ , i.e.,  $[eqn]$ is the collection of all subsets of $[eqn]$ of cardinality a.

2. Preliminaries

In this section, we first review the definition of the placement delivery array (PDA). Next, we review the traditional $[eqn]$ combination networks and a tool used to characterize their caching schemes, namely the combinatorial placement delivery array (CPDA). Finally, we formulate the $[eqn]$ combination network with multi-access caching considered in this paper.

2.1. Placement Delivery Array

The placement delivery array (PDA) was introduced in [4] to characterize the placement and delivery issues in shared-link networks and is defined as follows.

Definition 1(PDA [4]). positive integers $[eqn]$ and S, an  $[eqn]$ array $[eqn]$ , where $[eqn]$ , composed of a specific symbol “∗” and integers in $[eqn]$ , is called a $[eqn]$ placement delivery array (PDA) if the following conditions hold:

• C1. Each column has exactly Z stars.
• C2. Each integer in $[eqn]$ occurs at least once.
• C3. For any two distinct entries $[eqn]$ and $[eqn]$ , $[eqn]$ if only if
• a. * $[eqn]$ , i.e., they lie in distinct rows and distinct columns;*
• b. * $[eqn]$ , i.e., the corresponding $[eqn]$ subarray formed by rows $[eqn]$ and columns $[eqn]$ must be one of the following form,*

$$[eqn]$$

Note that, for ease of notation, the non-star entries in a PDA may sometimes be expressed using sets or vectors rather than integers.

Given a $[eqn]$ PDA, an F-division $[eqn]$ coded caching scheme can be obtained by interpreting rows as subpackets and columns as users, where the symbol “∗” indicates that the corresponding packet is cached at the user, while each non-star entry (integer, set, or vector) denotes a coded multicast transmission in the delivery phase.

Moreover, a PDA is called g-regular if each integer occurs exactly g times. The MN coded caching scheme proposed by Maddah-Ali and Niesen in [1] can be represented by a PDA, which is referred to as the MN PDA. It is defined as a $[eqn]$ array $[eqn]$

$$[eqn]$$

and $[eqn]$ . This means that each file is split into $[eqn]$ packets, each labeled by a t-subset of $[eqn]$ . In an MN PDA, the  $[eqn]$ row represents the $[eqn]$ packet of every file in the library, and the $[eqn]$ column corresponds to user k. An entry is “∗” if the user caches that packet (i.e., the user index belongs to the subset); otherwise, the entry is an integer or a vector indicating that the corresponding packets are simultaneously delivered in a coded transmission.

Example 1. It is easy to verify that the following array $[eqn]$ is a 3- $[eqn]$ MN PDA:

$$[eqn]$$

In (1), each subset is written as a string for short. For instance, the set $[eqn]$ is written as 12.

2.2. Traditional Combination Network and Combinatorial Placement Delivery Array

In an $[eqn]$ combination network [13], a server has access to a library of N files, denoted by $[eqn]$ , where each file $[eqn]$ consists of B independent and uniformly distributed random bits, and is connected through error-free and interference-free links to all H cache-less relays, say $[eqn]$ . The relays are connected via error-free and interference-free links to $[eqn]$ users, denoted by $[eqn]$ . Each r-subset $[eqn]$ of relay indices uniquely represents a user, and specifies the set of relays to which this user is connected, i.e.,  $[eqn]$ . The set of relays which connect to user $[eqn]$ is denoted by $[eqn]$ . Each user has a local cache memory of size $[eqn]$ bits.

The system operates in two phases:

• Placement phase: During the off peak traffic times, the server divides each file $[eqn]$ into F equal-length packets, i.e.,  $[eqn]$ . The parameter F is referred to as the subpacketization. Each user $[eqn]$ directly accesses to the file library $[eqn]$ and stores an arbitrary function thereof in its cache memory, subject to the space limitation of $[eqn]$ bits. For each user $[eqn]$ , the cache contents are denoted by $[eqn]$ , where $[eqn]$ is a placement function $[eqn]$ . The set of all cache contents is denoted by $[eqn]$ .
• Delivery phase: During the peak traffic times, each user $[eqn]$ requests a file $[eqn]$ from the server, where $[eqn]$ . The demand vector is $[eqn]$ , which is revealed to the server, the relays, and all users. For each $[eqn]$ , the server transmits a message to relay h:

$$[eqn]$$

where $[eqn]$ is an encoding function $[eqn]$ , and  $[eqn]$ is the size of $[eqn]$ . Each relay h forwards $[eqn]$ to all connected users. Each user k recovers its desired file $[eqn]$ from its accessible cache contents $[eqn]$ , the received signals $[eqn]$ , and the demand vector $[eqn]$ , i.e.,

$$[eqn]$$

where $[eqn]$ is a decoding function $[eqn]$ .

In such system, the worst-case number of files transmitted by each relay (also referred to as the load) over all possible requests should be minimized, which is defined as

$$[eqn]$$

For the coded caching problem in combination networks, the authors in [18] proposed a combinatorial structure, called the combinatorial placement delivery array (CPDA), which characterizes the placement and delivery issue in combination networks. Its definition is given as follows.

Definition 2(CPDA [18]). For positive integers $[eqn]$ , let $[eqn]$ . An  $[eqn]$ array $[eqn]$ with alphabet $[eqn]$ is called a $[eqn]$ combinatorial placement delivery array (CPDA) if it satisfies conditions C1–C3 in Definition 1 and the following conditions:

• C4. All the columns are labeled by $[eqn]$ , such that for any $[eqn]$ , the intersection of all column labels $[eqn]$ in which s appears, denoted by $[eqn]$ , is non-empty.

Using Algorithm 1, which was proposed in [19], a  $[eqn]$ CPDA leads to a coded caching scheme for the $[eqn]$ combination network. Algorithm 1 Caching scheme based on $[eqn]$ CPDA in [19]

• 1:procedure Placement( $[eqn]$ , $[eqn]$ )
• 2:      Split each file $[eqn]$ into F packets, i.e.,  $[eqn]$ .
• 3:      for  $[eqn]$  do
• 4:             $[eqn]$
• 5:      end for
• 6:end procedure
• 7:procedure Delivery( $[eqn]$ )
• 8:      for  $[eqn]$  do
• 9:             $[eqn]$
• 10:           $[eqn]$
• 11:          Divide $[eqn]$ into $[eqn]$ sub-packets, i.e.,  $[eqn]$
• 12:          for  $[eqn]$  do
• 13:                Server sends $[eqn]$ to relay $[eqn]$
• 14:                Relay $[eqn]$ broadcasts $[eqn]$ to its connecting users
• 15:          end for
• 16:   end for
• 17:end procedure

Lemma 1([19]). Given a $[eqn]$ CPDA and using Algorithm 1, we have an $[eqn]$ coded caching scheme with $[eqn]$ , subpacketization less than or equal to $[eqn]$ , and transmission rate for each relay $[eqn]$ .

Let us take the following example to further explain the connection between CPDA and Algorithm 1.

Example 2. It is easy to verify that the following array $[eqn]$ is a $[eqn]$ CPDA.

$$[eqn]$$

Based on the above CPDA $[eqn]$ , the following $[eqn]$ combination network coded caching scheme can be obtained by using Algorithm 1.

**Placement phase: ** * From line 2, each file $[eqn]$ is divided into $[eqn]$ packets denoted as $[eqn]$ . For any $[eqn]$ and $[eqn]$ , $[eqn]$ represents that user k caches the $[eqn]$ packet of all files, then from line 4, the cached content of all users are

$$[eqn]$$

**Delivery phase: ** * Assume that the demand vector is $[eqn]$ , i.e., user k requests file $[eqn]$ for $[eqn]$ . In the CPDA $[eqn]$ , each $[eqn]$ corresponds to a coded transmission. For each s, by line 9 of Algorithm 1, the server constructs

$$[eqn]$$

Let $[eqn]$ be the relay set given in condition C4 of Definition 2 where $[eqn]$ . Then $[eqn]$ is divided into $[eqn]$ sub-packets $[eqn]$ , where the server sends $[eqn]$ to relay $[eqn]$ and relay $[eqn]$ forwards it to its connected users. Thus the subpacketization is at most $[eqn]$ . For example, when $[eqn]$ , we obtain

$$[eqn]$$

So $[eqn]$ is split into $[eqn]$ sub-packets $[eqn]$ and $[eqn]$ , delivered via relays 4 and 5, respectively. User 6 can decode $[eqn]$ using $[eqn]$ together with its cached packets $[eqn]$ and $[eqn]$ . Similarly, users 9 and 10 recover $[eqn]$ and $[eqn]$ . By the same argument, every user can decode its requested uncached packets. Table 1 summarizes the transmissions. In Table 1, each relay sends $[eqn]$ packets, leading to the transmission rate for each relay $[eqn]$ .

The authors in [14], based on the cut-set approach in [13], extended the converse bound for shared-link coded caching under the constraint of uncoded cache placement to the $[eqn]$ combination network.

Lemma 2(Converse Bound [14]). For the $[eqn]$ combination network with $[eqn]$ , under the constraint of uncoded cache placement, the converse bound $[eqn]$ satisfies that

$$[eqn]$$

where $[eqn]$ .

2.3. Considered Model: Combination Network with Multiaccess Caching Model

In this subsection, we introduce an extended system model that integrates the combination network with multi-access caching, where each user is allowed to access L cache nodes deployed at the network edge.

Consider the $[eqn]$ combination network with a multi-access coded caching system as illustrated in Figure 1, where H and r are positive integers with $[eqn]$ , $[eqn]$ is the number of cache nodes, and L is the number of cache nodes accessible to each user. The system consists of a single server with a set of N equal-length files (denoted by $[eqn]$ ), H cache-less relays (denoted by $[eqn]$ ), $[eqn]$ users (denoted by $[eqn]$ ), and $[eqn]$ cache nodes (denoted by $[eqn]$ ). Each cache node has a memory size of M files where $[eqn]$ . The server is connected to all H relays through error-free and interference-free links. Each user $[eqn]$ is uniquely represented by an r-subset $[eqn]$ , and is connected via error-free and interference-free links to the r relays indexed by $[eqn]$ , i.e., $[eqn]$ . Moreover, each user $[eqn]$ can access an arbitrary subset of L cache nodes and retrieve cached contents from these cache nodes without any cost. In this paper, we assume that the communication bottleneck lies on the server-to-relay links.

The system operates in two phases:

• Placement phase: During off-peak traffic times, each cache node $[eqn]$ , where $[eqn]$ , stores some packets of each file subject to the memory size M. Let $[eqn]$ denote the cache contents at cache node $[eqn]$ . Each user $[eqn]$ can retrieve the contents cached at its accessible cache nodes. Let $[eqn]$ denote the cache contents retrievable by user k.
• Delivery phase: During peak traffic times, each user k requests a file $[eqn]$ from the server, where $[eqn]$ . The demand vector is $[eqn]$ , which is revealed to the server, the relays, and all users. For each $[eqn]$ , the server transmits a message $[eqn]$ to relay h, and then relay h forwards $[eqn]$ to all its connected users. Each user k recovers its desired file $[eqn]$ from its accessible cache contents $[eqn]$ , the received signals $[eqn]$ , and the demand vector $[eqn]$ .

The objective is to design a coded caching scheme that minimizes the worst-case load at each relay as defined in (2).

To describe the cache placement and packet retrievability under multi-access caching, we introduce two combinatorial structures, namely, the cache-node placement array $[eqn]$ and the user-retrieve array $[eqn]$ , which are defined as follows.

Definition 3. Let F denote the subpacketization, Λ the number of cache nodes, and K the number of users.

• The $[eqn]$ cache-node placement array $[eqn]$ consists of stars and nulls. The entry $[eqn]$ indicates that the j-th packet of each file, i.e., $[eqn]$ , is stored in cache node $[eqn]$ .
• The $[eqn]$ user-retrieve array $[eqn]$ consists of stars and nulls. The entry $[eqn]$ indicates that the j-th packet of each file, i.e., $[eqn]$ , can be retrieved by user k from its accessible cache nodes.

These two arrays provide a unified representation of which file packets are stored at each cache node and which packets can be retrieved by each user during the placement phase.

Note that, compared with the traditional combination network, the $[eqn]$ combination network with multi-access caching differs in the placement phase, where users retrieve cached contents from shared cache nodes rather than storing content independently. For the delivery phase, we can still use a CPDA $[eqn]$ to characterize the delivery strategy over the server–relay links. As a result, the design of a coded caching scheme for the $[eqn]$ combination network with multi-access caching is equivalent to the construction of three arrays: the cache-node placement array $[eqn]$ , the user-retrieve array $[eqn]$ , and the CPDA $[eqn]$ .

3. Main Results

3.1. Main Results and Performance Analysis

In this subsection, we present the main achievable results for the $[eqn]$ combination network with multi-access caching. We first show that the design of an achievable scheme in the regime $[eqn]$ and $[eqn]$ can be reduced to studying an effective $[eqn]$ setting. We then focus on this setting and provide a coded caching scheme.

Theorem 1. Consider the $[eqn]$ combination network with multi-access caching. Assume that $[eqn]$ , $[eqn]$ , and $[eqn]$ . An achievable scheme can be obtained by partitioning the users into groups of size at most $[eqn]$ and applying the same construction within each group. Equivalently, the scheme design for the $[eqn]$ network reduces to designing a scheme for the $[eqn]$ combination network with multi-access caching.

Proof. Let $[eqn]$ be the total number of users, where each user $[eqn]$ is indexed by an r-subset $[eqn]$ of relays to which it is connected. Since $[eqn]$ and $[eqn]$ , each user belongs to at least one $[eqn]$ -subset of relays that contains at least L of its connected relays.For each $[eqn]$ , define the (possibly overlapping) group of users

$$[eqn]$$

A user may belong to multiple groups $[eqn]$ ; in that case, we introduce a virtual copy of this user in each group in which it is served, which does not affect achievability (e.g., the virtual copies can be served in additional rounds via time-sharing). Moreover, $[eqn]$ holds for all $[eqn]$ when $[eqn]$ , $[eqn]$ , and $[eqn]$ . If $[eqn]$ , we serve the users in $[eqn]$ in multiple rounds, each round handling an arbitrary subset of $[eqn]$ users from $[eqn]$ (and time-sharing across rounds). Therefore, we consider a group $[eqn]$ with $[eqn]$ .Fix such a group $[eqn]$ . We activate only the relays in $[eqn]$ for serving the users in this group and keep all relays in $[eqn]$ silent during the transmissions intended for this group. For each user $[eqn]$ , choose an effective relay subset $[eqn]$ with $[eqn]$ , and let only the relays in $[eqn]$ participate in forwarding the messages intended for user k. Such a choice is always possible because $[eqn]$ by the definition of $[eqn]$ . Therefore, within this group, at most $[eqn]$ relays are involved in delivery.On the cache side, since each user can access an arbitrary subset of L cache nodes and $[eqn]$ , we can establish a one-to-one mapping from the users in $[eqn]$ to $[eqn]$ and assign distinct cache-access sets accordingly. Relabel the relays in $[eqn]$ as $[eqn]$ . Under the above relay activation and cache-access assignment, the group $[eqn]$ induces an effective $[eqn]$ instance. Applying any scheme designed for $[eqn]$ to each round and time-sharing across all rounds (and all $[eqn]$ ) yields an achievable scheme for the original $[eqn]$ network. □

We now present the following example to further illustrate the above reduction.

Example 3. Consider an $[eqn]$ combination network with multi-access caching. Users are indexed by $[eqn]$ , so $[eqn]$ .

Let $[eqn]$ be an arbitrary Λ-subset of relays. Without loss of generality, we consider $[eqn]$ . Define the associated user group as

$$[eqn]$$

The only user disjoint from $[eqn]$ is $[eqn]$ , hence $[eqn]$ . Since $[eqn]$ , we select an arbitrary subset of 3 users to be served in one round, e.g.,

$$[eqn]$$

Any remaining users in $[eqn]$ can be served in additional rounds via time-sharing. If desired, virtual users (replicas of existing users) can also be introduced so that a round uses any convenient set of three users; for instance, one may replicate users $[eqn]$ and $[eqn]$ and serve them together with $[eqn]$ in a round.

We serve the users in $[eqn]$ by activating only the relays in $[eqn]$ and keeping relays in $[eqn]$ silent. For each user $[eqn]$ , choose an effective relay set $[eqn]$ with $[eqn]$ (e.g., $[eqn]$ for $[eqn]$ , respectively).

On the cache side, there are $[eqn]$ cache nodes $[eqn]$ and each user can access $[eqn]$ cache node. Since $[eqn]$ has size 3, we establish a one-to-one mapping and assign

$$[eqn]$$

Relabel the relays in $[eqn]$ as $[eqn]$ . Under this relabeling, the above round induces an effective $[eqn]$ instance.

Motivated by Theorem 1, we henceforth focus on the $[eqn]$ combination network with multi-access caching. In particular, we consider the setting $[eqn]$ and $[eqn]$ , under which we propose a coded caching scheme and obtain the following achievable result. The detailed proof is provided in Section 4.

Theorem 2. For any integers H, r, and $[eqn]$ such that $[eqn]$ and $[eqn]$ , under $[eqn]$ and $[eqn]$ , there exists a coded caching scheme for the $[eqn]$ combination network with multi-access caching achieving memory ratio $[eqn]$ , subpacketization at most $[eqn]$ , and per-relay transmission rate

$$[eqn]$$

To evaluate the performance of the proposed scheme, we compare the achievable per-relay transmission load $[eqn]$ in Theorem 2 with the converse bound derived in [14], i.e., Lemma 2. Compared with the traditional $[eqn]$ combination network with end-user caches, the proposed $[eqn]$ combination network imposes additional structural constraints in the placement phase, in the sense that users do not possess independent local caches and can retrieve cached content only through their connected cache nodes. Consequently, the set of feasible coded caching schemes under the proposed multi-access model is a subset of the feasible schemes considered in [14]. Therefore, the converse bound in [14], derived under uncoded placement and a fixed relay–user topology, remains a valid bound for the proposed model and is adopted as a performance benchmark.

Note that the converse bound in [14] is expressed as a function of the cache size available at each user. Under the proposed scheme, although the cache placement is characterized by the cache-node memory ratio $[eqn]$ , each user can retrieve packets from multiple cache nodes through its combinatorial access pattern. As a result, the user-retrievable cache ratio is given by

$$[eqn]$$

as defined in (6). In the following, we adopt this quantity as the performance metric for comparison. Since both the achievable per-relay transmission load in Theorem 2 and the converse bound in Lemma 2 involve binomial coefficients, obtaining a closed-form analytical comparison is, in general, intractable. Therefore, we provide numerical comparisons for several system parameters. Figure 2 and Figure 3 illustrate the comparison for $[eqn]$ , $[eqn]$ , $[eqn]$ and $[eqn]$ , $[eqn]$ , $[eqn]$ , respectively.

It can be observed that when the user-retrievable cache ratio is small, the transmission load of the proposed scheme is higher than the converse bound in [14]. As the user-retrievable cache ratio increases, the gap between the achievable load and the converse bound gradually decreases.

3.2. Sketch of the Proposed Scheme in Theorem 2

Consider an $[eqn]$ combination network with multi-access caching. We specify the cache-access topology as follows. Since $[eqn]$ and $[eqn]$ , we have $[eqn]$ . Accordingly, a one-to-one mapping can be established from $[eqn]$ to $[eqn]$ to determine the cache-access set of each user. For simplicity of exposition, we use $[eqn]$ to denote both the relay set and the cache-access set of user k. That is, user k is connected to relays $[eqn]$ and can access cache nodes $[eqn]$ .

Let $[eqn]$ . The construction starts with the $[eqn]$ MN PDA $[eqn]$ from Example 1. Based on $[eqn]$ , we first construct the cache-node placement array $[eqn]$ (for the $[eqn]$ cache nodes), then derive the user-retrieve array $[eqn]$ (for the $[eqn]$ users), and finally generate the corresponding CPDA $[eqn]$ . The overall construction flow is illustrated in Figure 4.

Remark 1. When $[eqn]$ , a one-to-one mapping between $[eqn]$ and $[eqn]$ can be established. Here, for simplicity, we use $[eqn]$ to denote both the relay set and the cache-access set of user k.

Each file is divided into $[eqn]$ equal-length packets, i.e.,

$$[eqn]$$

The constructing contains the following three steps:

• Step 1. Construction of $[eqn]$ . We construct the cache-node placement array $[eqn]$ by vertically replicating the placement array of the MN PDA $[eqn]$ (i.e., the subarray consisting of all star entries) $[eqn]$ times. As a result, the array $[eqn]$ consists of r identical subarrays. For notational convenience and to avoid ambiguity, we refer to each of these subarrays as a block. According to Definition 3, a star entry in $[eqn]$ indicates that the corresponding packet is stored at the associated cache node. As illustrated in Step 1 of Figure 4, the array $[eqn]$ consists of $[eqn]$ identical subarrays, which are separated by an orange line. Each row of $[eqn]$ is indexed by an ordered pair $[eqn]$ , which corresponds to one packet of each file, while each column is indexed by $[eqn]$ , representing cache node $[eqn]$ . For instance, cache node $[eqn]$ stores the packets

$$[eqn]$$

This step ensures that the number of rows of $[eqn]$ matches the subpacketization $[eqn]$ and provides the structural basis for the subsequent construction of the CPDA.

• Step 2. Construction of $[eqn]$ . We construct the user-retrieve array $[eqn]$ according to the cache nodes accessible by each user. Specifically, each user $[eqn]$ is indexed by $[eqn]$ and can access the $[eqn]$ cache nodes indexed by $[eqn]$ , i.e., $[eqn]$ . According to Definition 3, the row indices of $[eqn]$ have the same meaning as those of $[eqn]$ , i.e., each row corresponds to one packet of each file. Therefore, the structure of $[eqn]$ can be directly induced by the cache-node placement array $[eqn]$ . In particular, since the placement of star entries in $[eqn]$ determines which packets are accessible to each user, the array $[eqn]$ also consists of r identical blocks. As illustrated in Step 2 of Figure 4, the array $[eqn]$ consists of $[eqn]$ identical blocks, which are separated by orange lines. Each row of $[eqn]$ is indexed by an ordered pair $[eqn]$ , corresponding to one packet of each file, while each column is indexed by $[eqn]$ , corresponding to user k. For instance, user 1 is indexed by $[eqn]$ and can access cache nodes $[eqn]$ and $[eqn]$ . So user 1 can retrieve the packets

$$[eqn]$$

• Step 3. Construction of $[eqn]$ . We construct the CPDA $[eqn]$ based on the user-retrieve array $[eqn]$ . Since the row and column indices of $[eqn]$ have the same meaning as those of $[eqn]$ , we obtain $[eqn]$ by filling the null entries of $[eqn]$ with appropriate symbols or vectors so that the array $[eqn]$ satisfies all the conditions in Definition 2. The construction consists of the following two substeps.- Step 3.1. For each null entry of $[eqn]$ indexed by row $[eqn]$ and column $[eqn]$ , we fill the entry with the union of the second coordinate of the row index and the column index, i.e., $[eqn]$ , to obtain an intermediate array $[eqn]$ . For instance, the null entry corresponding to row index $[eqn]$ and column index $[eqn]$ is filled with the set $[eqn]$ . Since the second coordinate $[eqn]$ of the row index follows the same ordering across all replicated blocks, the array $[eqn]$ consists of r identical blocks. As illustrated in Step 3.1 of Figure 4, the array $[eqn]$ consists of $[eqn]$ identical blocks, which are separated by an orange line. Consequently, each column of $[eqn]$ contains exactly $[eqn]$ star entries, which ensures condition C1 of Definition 2. Moreover, when restricted to any single block, the array $[eqn]$ satisfies conditions C1–C3 of Definition 2. For instance, the first block $[eqn]$ is given by

$$[eqn]$$

It is not difficult to verify that $[eqn]$ satisfies conditions C1–C3. However, since $[eqn]$ consists of r identical blocks, each column contains r identical non-∗ entries. As a result, the array $[eqn]$ does not yet satisfy conditions C3 and C4 of Definition 2.- Step 3.2. For each non-∗ entry in $[eqn]$ indexed by row $[eqn]$ and column $[eqn]$ , we assign the $[eqn]$ element of the column index $[eqn]$ , denoted by $[eqn]$ (under a fixed ordering of $[eqn]$ ), as the second coordinate, thereby obtaining the array $[eqn]$ . By distinguishing identical non-∗ entries appearing in different replicated blocks, this step ensures that the array $[eqn]$ satisfies conditions C3 and C4 of Definition 2. As illustrated in Step 3.2 of Figure 4, the integers highlighted in different colors in the column labels are assigned as the second coordinates to the non-∗ entries in different blocks, respectively. Next, we verify that the array $[eqn]$ satisfies conditions C3 and C4 of Definition 2. For instance, consider the subarray $[eqn]$ corresponding to the vector $[eqn]$ , i.e.,

$$[eqn]$$

We can verify that this subarray $[eqn]$ satisfies condition C3. Moreover, the corresponding column indices satisfy $[eqn]$ , which ensures that condition C4 is also satisfied.

Therefore, $[eqn]$ is a 3- $[eqn]$ CPDA. Based on the node-placement array $[eqn]$ , we have the memory ratio $[eqn]$ , and based on the CPDA $[eqn]$ , the transmission load for each relay is $[eqn]$ .

4. Proof of Theorem 2

We consider the $[eqn]$ combination network with multi-access caching with $[eqn]$ and $[eqn]$ . Let $[eqn]$ , where $[eqn]$ is an integer. We adopt the following cache-access topology. Since $[eqn]$ and $[eqn]$ , there exists a one-to-one mapping from $[eqn]$ to $[eqn]$ . Accordingly, each user k indexed by $[eqn]$ is assigned a unique cache-access set $[eqn]$ and can access the cache nodes $[eqn]$ at no cost. For simplicity of exposition, we take $[eqn]$ to be the identity mapping and write $[eqn]$ .

The proposed construction consists of three steps: (i) construction of the cache-node placement array $[eqn]$ ; (ii) construction of the user-retrieve array $[eqn]$ ; and (iii) construction of the CPDA $[eqn]$ . The definitions of $[eqn]$ and $[eqn]$ are given in Definition 3, and the definition of $[eqn]$ is given in Definition 2.

Each file is divided into $[eqn]$ equal-length packets, i.e.,

$$[eqn]$$

4.1. Placement Strategy for Cache Nodes: Generation of C

Based on the sketch provided in Section 3.2, each row of $[eqn]$ is indexed by an ordered pair $[eqn]$ , which corresponds to one packet of each file, while each column is indexed by $[eqn]$ , representing cache node $[eqn]$ . According to Definition 3, we define the $[eqn]$ cache-node placement array $[eqn]$ as follows:

$$[eqn]$$

Accordingly, each cache node $[eqn]$ stores the following set of packets:

$$[eqn]$$

Hence, the memory size of each cache-node is $[eqn]$ , satisfying the memory size constraint. The memory ratio is $[eqn]$ .

4.2. Packets Retrievable to Users: Generation of U

Given the cache-node placement array $[eqn]$ constructed above, we derive the corresponding user-retrieve array $[eqn]$ . The rows of $[eqn]$ are indexed by ordered pairs $[eqn]$ , corresponding to one packet of each file, and the columns are indexed by $[eqn]$ , corresponding to user k.

Recall that each user $[eqn]$ can access the r cache nodes indexed by $[eqn]$ , i.e., $[eqn]$ . By the construction of the cache-node placement array $[eqn]$ , the entry $[eqn]$ is a star if and only if cache node $[eqn]$ stores the packet $[eqn]$ , which occurs precisely when $[eqn]$ . Hence, user k can retrieve packet $[eqn]$ if and only if at least one of its accessible cache nodes stores it, i.e., if and only if $[eqn]$ .

Therefore, we define the $[eqn]$ user-retrieve array $[eqn]$ as

$$[eqn]$$

Accordingly, user k can retrieve the packet set

$$[eqn]$$

For a fixed user k, among all $[eqn]$ subsets $[eqn]$ with $[eqn]$ , the number of subsets satisfying $[eqn]$ is $[eqn]$ . Therefore, the number of retrievable subsets $[eqn]$ is $[eqn]$ . Since each such subset $[eqn]$ corresponds to r packets indexed by $[eqn]$ , the total number of packets retrievable by user k is $[eqn]$ . As each file is divided into $[eqn]$ packets, the fraction of each file retrievable by user k through its accessible cache nodes is

$$[eqn]$$

4.3. Delivery Strategy: Generation of CPDA P

Finally, based on the sketch in Section 3.2 and the user-retrieve array $[eqn]$ , we construct the CPDA $[eqn]$ , which specifies the coded multicast delivery strategy. The array $[eqn]$ has the same row and column indexing as $[eqn]$ and is obtained by filling the null entries of $[eqn]$ with two-dimensional vectors.

The CPDA $[eqn]$ is generated according to the following construction.

Construction 1. For any positive integers H, r, and $[eqn]$ satisfying $[eqn]$ and $[eqn]$ . Let $[eqn]$ and $[eqn]$ . Clearly, $[eqn]$ and $[eqn]$ . We construct a $[eqn]$ array $[eqn]$ , where for each $[eqn]$ and $[eqn]$ ,

$$[eqn]$$

where $[eqn]$ denotes the $[eqn]$ element of $[eqn]$ under a fixed ordering of its elements.

By construction, the CPDA $[eqn]$ jointly characterizes the cache placement, packet retrievability, and the coded multicast delivery strategy for the considered combination network with multi-access caching with $[eqn]$ and $[eqn]$ . Therefore, we have the following result, whose proof is provided in Appendix A.

Proposition 1. For the $[eqn]$ combination network with multi-access caching with $[eqn]$ and $[eqn]$ , and memory ratio $[eqn]$ where $[eqn]$ , the array $[eqn]$ generated by Construction 1 is a $[eqn]$ − $[eqn]$ CPDA, which leads to a combination network with multi-access coded caching scheme with subpacketization at most $[eqn]$ and transmission load for each relay $[eqn]$ .

After determining the CPDA $[eqn]$ , the corresponding delivery procedure is as follows. From line 9 of Algorithm 1, for each integer $[eqn]$ , the server sends the coded multicast message $[eqn]$ to the relays. Each relay then forwards its received message to the connected users so that each user can decode its requested packets from the multicast messages.

5. Conclusions

This paper studied coded caching for the $[eqn]$ combination network with multi-access caching. To capture the cache placement and packet-retrievability structure, we introduced two combinatorial representations, namely the cache-node placement array and the user-retrieve array. Focusing on the case $[eqn]$ and $[eqn]$ , we proposed a coded caching scheme for the considered network. We also provided numerical comparisons using the user-retrievable cache ratio as the comparison metric, benchmarked against the converse bound of the traditional combination network. The results indicate that the proposed scheme approaches the converse bound, and the performance gap gradually diminishes as the cache ratio increases.

Future work includes extending the proposed constructions to more general, possibly non-combinatorial and heterogeneous connectivity patterns between users, relays, and cache nodes, and establishing tighter achievable and converse bounds for such irregular topologies.