Hotplug Placement Delivery Arrays (HpPDAs)

• HpPDAs are a combinatorial framework for centralized coded caching that decouples placement and delivery to accommodate unknown offline users.
• They leverage a dual-array structure—using a star-only array for placement and a classical PDA for active users—to ensure efficient multicast delivery.
• Different constructions like MAN-HpPDAs and t-design based HpPDAs, including MDS-coded and secretive variants, enable optimized memory-rate-subpacketization trade-offs.

Searching arXiv for the cited HpPDA and hotplug coded caching papers to ground the article and confirm metadata. Hotplug Placement Delivery Arrays (HpPDAs) are a combinatorial abstraction for centralized coded caching systems in which only a subset of users is active during the delivery phase. They generalize the classical Placement Delivery Array (PDA) formalism by separating placement structure from delivery structure: an HpPDA consists of a star-only array over all users together with a classical PDA over the active users, linked by a matching condition that must hold for every possible active subset. This construction captures the defining hotplug constraint that placement is performed without knowing which users will later be offline, while delivery must still exploit coded multicast opportunities among whichever $K'$ users are active. HpPDAs were introduced for hotplug coded caching and subsequently used to derive MAN-induced and $t$-design-based schemes, later extended with MDS-coded placement and, under information-theoretic secrecy constraints, with secret sharing, Cauchy-matrix mixing, and masking keys (Rajput et al., 2023, Chinnapadamala et al., 2024, Chinnapadamala et al., 18 Jul 2025).

1. Origin and system model

Hotplug coded caching modifies the Maddah-Ali–Niesen setting by allowing some users to be offline during delivery. In a $(K,K',N)$ hotplug system, a server stores $N$ files and serves $K$ users over an error-free shared link, but exactly $K'$ users are active during delivery; the identities of those active users are unknown at placement time, although the value of $K'$ is known (Chinnapadamala et al., 2024). Placement is centralized and demand-agnostic, and delivery must succeed for every active subset $I \subseteq [K]$ with $|I|=K'$ (Rajput et al., 2023).

This model was first introduced by Ma and Tuninetti, and HpPDAs were later formulated to encode the combinatorial condition that a single placement pattern must support any realization of the active set (Chinnapadamala et al., 2024, Rajput et al., 2023). A fundamental implication of the hotplug model is that the system cannot outperform a classical coded caching problem with $K'$ users, so converse bounds for the classical setting apply with $t$0 replaced by $t$1 (Chinnapadamala et al., 2024). In the secretive hotplug setting, an additional lower bound from private or secretive coded caching implies $t$2, so at least one file-size transmission is necessary under secrecy (Chinnapadamala et al., 18 Jul 2025).

The central design objectives are therefore threefold: robustness to unknown offline users, efficient multicast coding during delivery, and control of rate, memory, and subpacketization. HpPDAs provide a compact way to express all three.

2. Formal definition and relation to classical PDAs

A classical $t$3-PDA is an $t$4 array whose entries are either stars or integers, with exactly $t$5 stars in each column, every integer appearing at least once, and the standard PDA cross condition requiring that if the same integer appears twice, the corresponding $t$6 subarray has stars off the diagonal (Chinnapadamala et al., 18 Jul 2025). A PDA induces a classical coded caching scheme with subpacketization $t$7, cache ratio $t$8, and rate $t$9 (Chinnapadamala et al., 18 Jul 2025, Chinnapadamala et al., 2024).

An HpPDA replaces the single array by a pair $(K,K',N)$0. In the formulation used in the hotplug literature, $(K,K',N)$1 is an $(K,K',N)$2 array with entries either “$(K,K',N)$3” or null, each column containing exactly $(K,K',N)$4 stars, while $(K,K',N)$5 is an $(K,K',N)$6 classical $(K,K',N)$7-PDA (Chinnapadamala et al., 18 Jul 2025, Chinnapadamala et al., 2024). The defining hotplug matching condition is that for every active subset $(K,K',N)$8 with $(K,K',N)$9, there exists a row subset $N$0 with $N$1 such that the subarray $N$2 has the same star pattern as $N$3 (Rajput et al., 2023).

This condition is the core of the framework. It means that once the active users are known, the server can select the corresponding rows $N$4, fill the null entries of $N$5 with the integer labels of $N$6, and recover a valid PDA for those active users. Delivery then proceeds exactly as in the classical PDA setting, but only on the induced subarray (Chinnapadamala et al., 2024). Offline users simply disappear from the induced delivery instance; the combinatorial structure required for decodability survives because the star pattern of $N$7 is guaranteed to appear inside $N$8 for every active set (Chinnapadamala et al., 18 Jul 2025).

The parameter mapping depends on the specific construction. In the uncoded HpPDA scheme of the original formulation, the achievable point is

$N$9

with MDS coding across the $K$0 subfiles to generate $K$1 coded subfiles (Rajput et al., 2023). In the later MDS-coded hotplug scheme, the placement dimension is enlarged to $K$2, yielding

$K$3

with operational subpacketization $K$4 (Chinnapadamala et al., 2024). In the secretive setting, the delivery load becomes

$K$5

because each multicast transmission carries one coded share of size $K$6 (Chinnapadamala et al., 18 Jul 2025).

3. Placement and delivery mechanisms

The original HpPDA-based hotplug scheme uses an $K$7 MDS code across file subfiles. Each file is partitioned into $K$8 equal-sized subfiles and encoded into $K$9 coded subfiles indexed by the rows of $K'$0; user $K'$1 stores precisely those coded subfiles corresponding to star positions in column $K'$2 of $K'$3 (Rajput et al., 2023). When an active set $K'$4 is revealed, the server chooses a row subset $K'$5 whose star pattern over columns $K'$6 matches $K'$7, fills the non-star entries with the integers of $K'$8, and for each integer $K'$9 broadcasts the XOR of the coded subfiles indexed by entries equal to $K'$0 (Rajput et al., 2023).

The correctness argument is inherited from the classical PDA formalism. Because $K'$1 satisfies the PDA cross condition, every user participating in a multicast already holds the interfering coded subfiles as side information and can therefore recover its desired coded subfile from that transmission (Chinnapadamala et al., 2024). Each active user obtains $K'$2 coded packets from delivery and already has $K'$3 coded packets from placement; with an $K'$4 MDS code of dimension $K'$5, these $K'$6 coded packets suffice to reconstruct the entire file (Chinnapadamala et al., 2024).

The later MDS-coded scheme of Rajput and Rajan retains the same HpPDA combinatorics but shifts the operating point to lower memory. For a fixed HpPDA $K'$7, the earlier uncoded construction operates at $K'$8, whereas the new scheme operates at $K'$9. Since $I \subseteq [K]$0, it follows that

$I \subseteq [K]$1

so the new scheme moves to a smaller memory point and improves rate behavior in lower-memory regimes relative to the prior HpPDA-based construction (Chinnapadamala et al., 2024).

A worked MAN-HpPDA example appears repeatedly in the literature: for $I \subseteq [K]$2, $I \subseteq [K]$3, and $I \subseteq [K]$4, the parameters are $I \subseteq [K]$5, $I \subseteq [K]$6, $I \subseteq [K]$7, $I \subseteq [K]$8, and $I \subseteq [K]$9 (Rajput et al., 2023, Chinnapadamala et al., 2024, Chinnapadamala et al., 18 Jul 2025). In the non-secretive MDS-coded realization, $|I|=K'$0, so a $|I|=K'$1 MDS code is used and the achieved point is $|I|=K'$2 (Chinnapadamala et al., 2024). In the earlier HpPDA realization with $|I|=K'$3, the same combinatorics yield $|I|=K'$4 (Rajput et al., 2023). This contrast illustrates how the same HpPDA can support different caching schemes depending on the coding layer placed on top of it.

4. Principal HpPDA constructions

Two HpPDA classes are explicitly identified in the literature: MAN-HpPDAs and HpPDAs derived from $|I|=K'$5-designs (Chinnapadamala et al., 18 Jul 2025).

MAN-HpPDAs

MAN-HpPDAs are obtained by taking the MAN PDA over $|I|=K'$6 users as the active-user delivery array $|I|=K'$7, and the MAN PDA over $|I|=K'$8 users with all integer entries replaced by null as the global placement array $|I|=K'$9 (Rajput et al., 2023). For integers $K'$0, $K'$1, and $K'$2, the resulting parameters are

$K'$3

The HpPDA property follows from the combinatorial alignment of $K'$4-subsets: for any active set of size $K'$5, the rows corresponding to the $K'$6-subsets of that active set provide the required star pattern (Chinnapadamala et al., 18 Jul 2025).

In the secretive setting, the MAN-HpPDA scheme achieves

$K'$7

and

$K'$8

with the special case $K'$9 yielding $t$00, which is optimal under the secrecy lower bound $t$01 (Chinnapadamala et al., 18 Jul 2025).

HpPDAs from $t$02-designs

The second class is derived from a $t$03-$t$04 design $t$05, with users indexed by points and rows indexed by blocks (Rajput et al., 2023, Chinnapadamala et al., 18 Jul 2025). The star-only array $t$06 is the transposed incidence matrix with “1” replaced by “$t$07” and “0” by null, so $t$08, $t$09, and each column has $t$10 stars (Rajput et al., 2023). The delivery PDA $t$11 is assembled from rows indexed by pairs $t$12, where $t$13 is an $t$14-subset of $t$15 and $t$16, for chosen integers $t$17 satisfying $t$18 (Chinnapadamala et al., 18 Jul 2025).

The resulting parameters are

$t$19

and $t$20 is an HpPDA for $t$21 (Chinnapadamala et al., 18 Jul 2025). This construction is significant because it allows more flexible parameter tuning than MAN-HpPDAs and can reduce subpacketization relative to $t$22 in MAN-based schemes (Chinnapadamala et al., 18 Jul 2025).

The earlier $t$23-scheme literature also studies rate improvement by deleting certain integer labels from $t$24 when $t$25, thereby reducing transmissions while preserving decodability (Rajput et al., 2023). For MAN-HpPDAs this yields an improved rate

$t$26

and for the $t$27-design case a more general deletion formula based on layered MAN subarrays inside $t$28 (Rajput et al., 2023). This suggests that HpPDAs should be viewed not merely as static combinatorial objects, but as a basis for subsequent transmission-pruning mechanisms.

5. Secretive HpPDAs and information-theoretic secrecy

The paper "Secretive Hotplug Coded Caching" extends HpPDA-based hotplug systems with perfect information-theoretic secrecy (Chinnapadamala et al., 18 Jul 2025). The secrecy model assumes honest-but-curious, non-colluding users and public server transmissions. Two secrecy constraints are imposed. First, cache secrecy requires

$t$29

so a cache alone reveals no information about any file (Chinnapadamala et al., 18 Jul 2025). Second, for each active user $t$30 demanding $t$31, decodability and delivery secrecy require

$t$32

where $t$33 denotes the delivery transmissions (Chinnapadamala et al., 18 Jul 2025).

The proposed secretive schemes share several coding ingredients. Each file is split into $t$34 equal-size parts and encoded using a $t$35 non-perfect secret sharing scheme, so any set of at most $t$36 shares leaks no information, while $t$37 shares suffice to reconstruct the file (Chinnapadamala et al., 18 Jul 2025). These shares are formed by linear combinations of file parts and independent keys via a square Cauchy matrix, ensuring that every submatrix is full rank and preventing linear leakage (Chinnapadamala et al., 18 Jul 2025). The resulting $t$38 shares are then encoded by an $t$39 MDS code to produce $t$40 coded shares indexed by the rows of $t$41, and each cache stores the $t$42 coded shares corresponding to star positions in its column (Chinnapadamala et al., 18 Jul 2025).

Additional random vectors $t$43 are stored as one-time-pad keys to mask transmissions that are not useful to all active users (Chinnapadamala et al., 18 Jul 2025). In the secretive MAN-HpPDA scheme, for each $t$44-subset $t$45 of active users, the server transmits

$t$46

and only users in $t$47 possess the key $t$48 needed to remove the mask (Chinnapadamala et al., 18 Jul 2025). In the $t$49-design-based secretive scheme, multicast signals indexed by subsets $t$50 with $t$51 are similarly masked, while transmissions useful to all active users, corresponding to $t$52, need not be masked (Chinnapadamala et al., 18 Jul 2025).

A baseline secretive scheme, adapted from the classical PDA setting of Meel–Rajan, uses a $t$53-PDA $t$54 directly and achieves memory

$t$55

and rate $t$56, where the additional $t$57 term reflects a complete per-file key budget (Chinnapadamala et al., 18 Jul 2025). The HpPDA-based secretive schemes exploit the larger ambient $t$58 through the placement array $t$59 and outperform this baseline in specific memory ranges (Chinnapadamala et al., 18 Jul 2025).

6. Performance, complexity, and known trade-offs

The literature emphasizes that HpPDAs are primarily a mechanism for navigating the memory–rate–subpacketization trade-off under hotplug constraints. Their main benefit is structural robustness: placement is fixed once for all users, yet delivery can adapt to any active subset through the subarray matching property (Rajput et al., 2023, Chinnapadamala et al., 18 Jul 2025).

The following table summarizes the principal parameter mappings that recur across the literature.

Construction	Achievable point	Notes
Original HpPDA scheme	$t$60	Uses $t$61 MDS coding (Rajput et al., 2023)
MDS-coded HpPDA scheme	$t$62	Extends operation to lower memory (Chinnapadamala et al., 2024)
Secretive HpPDA scheme	$t$63	Adds non-perfect secret sharing, Cauchy mixing, masking (Chinnapadamala et al., 18 Jul 2025)

For MAN-HpPDAs, the subpacketization $t$64 grows combinatorially with $t$65, which can be prohibitive (Chinnapadamala et al., 18 Jul 2025). This is one of the major practical limitations of the MAN family. The $t$66-design-based HpPDAs can have substantially smaller $t$67, where $t$68 is the number of blocks in the underlying design, and are therefore presented as a way to improve practicality while retaining good memory–rate performance (Chinnapadamala et al., 18 Jul 2025). The MDS and secret-sharing layers add further linear-algebraic complexity: MDS encoding and decoding involve finite-field operations across $t$69 coded packets, and the secretive schemes additionally require Cauchy-matrix-based share generation and one-time-pad key handling (Chinnapadamala et al., 18 Jul 2025).

Several numerical comparisons are reported. For $t$70, the secretive MAN-HpPDA scheme outperforms the secretive baseline in the low-memory region $t$71, with load decreasing from $t$72 to $t$73, while the secretive $t$74-design HpPDA scheme derived from a $t$75-$t$76 design outperforms the baseline in $t$77, with $t$78 from $t$79 down to $t$80 (Chinnapadamala et al., 18 Jul 2025). For $t$81, the MAN-HpPDA scheme beats the baseline for $t$82, and the $t$83-design scheme from a $t$84-$t$85 design beats the baseline over $t$86; between $t$87 and $t$88, the $t$89-design scheme is better than MAN-HpPDA, while below $t$90, MAN-HpPDA is better among the proposed schemes (Chinnapadamala et al., 18 Jul 2025).

In the non-secretive MDS-coded setting, the same pattern appears. For $t$91 with a $t$92-$t$93 design, the points $t$94 and $t$95 improve over both the baseline and the improved $t$96-scheme in the memory interval from $t$97 to $t$98 file units (Chinnapadamala et al., 2024). For $t$99, improvement is reported from $(K,K',N)$00 with $(K,K',N)$01 to $(K,K',N)$02 with $(K,K',N)$03 (Chinnapadamala et al., 2024).

These results suggest a stable qualitative pattern: MAN-HpPDAs tend to be stronger in lower-memory regimes, while $(K,K',N)$04-design HpPDAs become competitive or superior in moderate-memory regimes, especially when reduced subpacketization is valuable (Chinnapadamala et al., 18 Jul 2025). The papers stop short of a universal dominance statement, and the observed behavior is explicitly parameter-dependent.

7. Extensions, variants, and open directions

HpPDAs have already been generalized beyond the original dedicated-cache single-access model. A 2026 extension introduces a generalized HpPDA for combinatorial multi-access hotplug networks, where each user accesses multiple caches and only a subset of caches is online during delivery (Singh et al., 15 Jan 2026). In that framework, a cache-level star array $(K,K',N)$05, a derived user-level array $(K,K',N)$06, and a family of PDAs $(K,K',N)$07 indexed by the number of online neighboring caches together replace the single pair $(K,K',N)$08 (Singh et al., 15 Jan 2026). This generalization preserves the central HpPDA principle—matching star patterns for every admissible online configuration—while broadening the topology to multi-access networks.

Several open directions are explicitly noted in the secretive hotplug literature. One is collusion: the current secrecy guarantees are for honest-but-curious, non-colluding users, and extending them to colluding sets remains open (Chinnapadamala et al., 18 Jul 2025). Another is decentralized placement: all HpPDA constructions discussed are centralized, and a decentralized hotplug analog with secrecy is not yet provided (Chinnapadamala et al., 18 Jul 2025). Heterogeneous cache sizes, joint file secrecy and demand privacy, and extensions to multi-server, combination-network, D2D, or fog-RAN settings are also identified as unresolved problems (Chinnapadamala et al., 18 Jul 2025).

A further issue is subpacketization reduction. This theme already appears in the non-secretive literature, where $(K,K',N)$09-design constructions are valued partly because they can reduce $(K,K',N)$10 relative to MAN-HpPDAs (Rajput et al., 2023, Chinnapadamala et al., 2024). The multi-access generalization continues this emphasis by allowing tunable parameters $(K,K',N)$11 that control redundancy elimination and subpacketization (Singh et al., 15 Jan 2026). A plausible implication is that future HpPDA research will focus less on introducing the abstraction itself—which is now mature—and more on exploiting it as a design template for new combinatorial families with better rate–memory–subpacketization trade-offs under richer operational constraints.

In summary, HpPDAs occupy a specific role in coded caching theory: they are the canonical combinatorial mechanism for hotplug robustness. Their importance lies not in a single scheme, but in the way they decouple global placement from active-set-specific delivery. MAN-HpPDAs and $(K,K',N)$12-design HpPDAs provide the two foundational construction classes, the MDS-coded refinement shifts achievable points to lower memory, and the secretive extension shows that the same combinatorial skeleton can support perfect information-theoretic secrecy through layered coding and masking (Rajput et al., 2023, Chinnapadamala et al., 2024, Chinnapadamala et al., 18 Jul 2025).