{"id":"aa93542f-a02c-4b89-9642-f84dd636e184","arxiv_id":"2507.13961","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":2,"one_line_summary":"Two secretive hotplug coded caching schemes are constructed from MAN-HpPDAs and t-design HpPDAs, with better rates than a baseline in certain memory regions.","lead":"This paper adds a secrecy constraint to hotplug coded caching, where some users are offline during delivery, and builds two schemes from known hotplug placement-delivery arrays. If correct, these are the first secretive hotplug caching schemes and beat a baseline in some memory ranges.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Secrecy proof in Theorems 1–2 analyzes raw Cauchy shares, not the MDS-coded shares actually cached; the MDS property alone does not preserve the privacy threshold, so condition (1) is unproven.","rationale":"The central claim of Theorems 1 and 2 is existence of a secretive hotplug scheme. For that claim to hold, condition (1), cache-only secrecy, must be proved for the actual cache content. The Section V proof shows that the raw shares \\tilde{W}_{i,s} generated by the Cauchy matrix in (9) form a non-perfect secret-sharing scheme: any m raw shares are statistically independent of the file. But the placement step applies an arbitrary (F,n) MDS code to produce coded shares C_{i,T}, and those are the objects stored in the caches. The secrecy of m MDS-coded shares is not implied by the secrecy of m raw shares. The key-coefficient matrix for a user is A_key^T M_U, where A_key is the n×m key part of the Cauchy matrix and M_U are the m columns of the MDS generator assigned to that user's cache. MDS only guarantees that every n columns of the generator are independent; it imposes no condition on A_key^T M_U. The minimal counterexample in the concrete test confirms that an MDS code can even make a single coded share a deterministic function of W. Thus the proof has a genuine hole, not a cosmetic omission. The same gap appears in Theorem 2, where the sentence 'the number of coded shares ... is Z' wrongly equates Z MDS-coded shares with Z secret-sharing shares. The baseline comparison is also under-specified, but the MDS-secrecy gap is more central because it attacks the defining condition (1). My read agrees with the reader's weakest_assumption; the verdict remains REJECT.","tokens_in":18759,"tokens_out":16756,"duration_ms":200131,"concrete_test":"Analytic check: isolate the MDS-composition step. Over F_5, take the Cauchy matrix A=[[4,1],[1,2]] with X={1,3}, Y={2,0}, and let the (3,2) MDS generator have columns u=(2,4), e1, e2. With n=2, m=1, one file part W and one key Y, the first coded share is C_1 = S^T u = 2S_1+4S_2 = 2W, so a single cached share leaks W. This shows the MDS property alone cannot carry the secrecy step. For the paper's exact schemes, add the missing rank test: for Example 3, write user 1's seven cached shares as L_W W + L_Y Y, with W the 4 file parts and Y the 7 keys, and compute rank(L_Y); if rank is below 7, condition (1) fails for that choice of MDS code. The theorem needs a proof that every user's cached column set keeps this rank equal to the number of cached shares.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The most load-bearing gap is in Section V (and repeated in Section VI): the proof of the cache-secrecy condition (1) analyzes the wrong random variables. Equation (9) produces n Cauchy-matrix shares \\tilde{W}_{i,s} and proves that any m of these raw shares satisfy the non-perfect secret-sharing guarantee (7). But the actual placement in (10)–(11) stores C_{i,T}, which are images of \\tilde{W}_{i,s} under an unspecified (F,n) MDS code. A linear MDS map does not automatically preserve the privacy threshold. For a user who holds m coded shares, secrecy requires that the m×m key-coefficient matrix has full rank m; this is a condition on the interaction between the MDS generator and the Cauchy matrix, and the paper neither states nor proves it. The same error is explicit in Theorem 2's proof: 'the number of coded shares of each file that are stored in each cache is Z' is taken to imply the (Z, F'-Z+Z) secret-sharing guarantee, although the cache holds Z MDS-coded shares, not Z raw shares. This is load-bearing because if the key-coefficient matrix is singular, condition (1) fails and a user can learn a linear function of the file from its cache alone. The construction may be repairable by choosing the MDS generator carefully, but as written Theorem 1 and Theorem 2 are not proven.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper introduces a secrecy constraint into the hotplug coded caching model and proposes two secretive schemes, one based on MAN-HpPDAs and one based on HpPDAs constructed from t-designs. The claimed achievable memory-rate pairs are stated in Theorem 1 and Theorem 2. Each file is first encoded with a non-perfect secret-sharing scheme, the resulting shares are expanded through an MDS code, and selected coded shares together with random keys are placed in the caches; the HpPDA structure is then used to construct the multicast transmissions. The paper proves correctness and rate, gives a secrecy argument based on the Cauchy-matrix construction of the raw shares, and numerically compares the two schemes with a baseline PDA-based secretive scheme for (8,3,8) and (12,3,12) hotplug systems. The main theorems are not proven as written because the secrecy proof analyzes the raw Cauchy shares rather than the MDS-coded shares that are actually stored in the caches.","tokens_in":19044,"tokens_out":14800,"duration_ms":175898,"significance":"If the secrecy proof can be repaired, the paper makes a useful first contribution to secrecy in hotplug coded caching. The rate-memory expressions are derived transparently from the HpPDA parameters rather than fitted to numerical data, and the correctness arguments for the delivery phase are mostly sound. The numerical comparison with the baseline scheme is clearly presented and gives concrete regions of memory where the proposed schemes are claimed to be better. However, the central claim of the paper is the existence of secretive schemes satisfying condition (1), and the current manuscript does not prove that condition for the MDS-coded cache content. The gap is local and appears repairable, so I treat this as a major-revision issue rather than an immediate rejection.","major_comments":[{"comment":"The placement stores the MDS-coded shares C_{i,T}, which are images of the raw shares \\tilde{W}_{i,s} under an unspecified MDS generator matrix G. The secrecy proof, however, proves the non-leak property only for any m raw shares \\tilde{W}_{i,l_1},...,\\tilde{W}_{i,l_m}, using the full-rank property of the Cauchy key submatrix A_2. For the m coded shares held by user k, the key-coefficient matrix is G_U A_2, where G_U is the m x n slice of the MDS generator corresponding to those coded shares. A linear MDS map does not preserve the non-perfect secret-sharing guarantee in general: if G_U A_2 is singular, a linear function of the file is recoverable from the cache alone, violating condition (1). The paper neither states nor proves that G_U A_2 has full rank for every user, so Theorem 1 is unproven as written.","section":"Section V, Proof of Secrecy, equations (9)-(11)"},{"comment":"The secrecy argument for the t-design scheme asserts that because each file is encoded with a (Z, F'-Z'+Z) non-perfect secret-sharing scheme and each cache stores Z coded shares, the cache leaks nothing. This implication is invalid: the secret-sharing guarantee applies to the raw shares, while the cache stores coded shares produced by the (F, F'-Z'+Z) MDS code. The fact that the number of stored coded shares equals Z is not sufficient to conclude the (Z, F'-Z'+Z) privacy threshold holds for those coded shares. A separate argument involving the MDS generator is required; without it, condition (1) is unproven for Theorem 2.","section":"Section VI, Secrecy paragraph"},{"comment":"The same gap appears in the t=K'-1 case. The placement in equation (14) stores shares indexed by T, after the text says that an MDS code is used to generate (K choose K'-1) coded shares. If \\tilde{W}_{i,T} in (14) denotes the MDS-coded shares, then the invocation of the non-perfect secret-sharing scheme immediately after (14) is unjustified for the same reason as in Section V. If, on the other hand, \\tilde{W}_{i,T} denotes the raw shares, then the role and parameters of the MDS code in this subsection need to be clarified. Either way, the secrecy claim in the t=K'-1 case is not established as written.","section":"Section V-A, Scheme when t=K'-1"}],"minor_comments":[{"comment":"In the displayed transmissions X_{\\{1,4,5\\}} and X_{\\{1,4,6\\}}, the terms C_{d4,\\{1,5\\}} and C_{d4,\\{1,6\\}} are repeated; the intended terms should be C_{d5,\\{1,4\\}} and C_{d6,\\{1,4\\}}.","section":"Example 1, Delivery Phase"},{"comment":"The range t \\in [0:K'-2] is inconsistent with Section V-A, which treats the case t=K'-1, and with the statement that R=1 is achievable at M=N(K-1 choose K'-2). The range should be corrected or the t=K'-1 case should be excluded from Theorem 1 and stated separately.","section":"Theorem 1, statement"},{"comment":"The printed arrays P in Examples 2 and 3 appear incomplete: the rows show only a few star entries and no non-star labels for the relevant subarrays, so the reader cannot verify the HpPDA structure or the transmissions from the typeset examples.","section":"Examples 2 and 3, displayed arrays"},{"comment":"The Cauchy matrix is defined over F_{2^l}, while the file parts and keys are described as elements of F_2^{B/(K'-1 choose t)}. The paper should specify how the arithmetic over F_{2^l} interacts with the binary representation of the shares and keys.","section":"Section V, Placement Phase"},{"comment":"The comparison plots connect discrete achievable memory-rate points by line segments; the paper should state explicitly whether memory sharing / file splitting is being used to justify the intermediate points on the curves.","section":"Section VII, Numerical comparisons"}],"recommendation":"major_revision","confidential_remarks":"The blocking issue is the unproven secrecy of the MDS-coded cache content in both main theorems and in the t=K'-1 special case. This is a single, local technical gap, and the construction may be repairable by adding a lemma that chooses the MDS generator so that every user's m x n slice G_U satisfies the required full-rank condition. If the authors cannot supply such a lemma, the central existence claims would not be established and rejection would be appropriate."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The paper is a first attempt at secrecy in hotplug coded caching, and the high-level idea is sensible: take secretive PDA schemes and wrap the HpPDA structure around them. But the central secrecy proof in Theorems 1 and 2 is not valid as written, because it proves privacy for raw secret-sharing shares while the caches store MDS-coded linear images of those shares. The main claim is therefore unsupported.\n\nWhat is genuinely new: nobody has combined the hotplug model with the secrecy constraint in (1)-(3). The two constructions extend secretive PDA caching to the two known HpPDA families, reduce to the known scheme when K=K', and give explicit rate-memory pairs. The rate formulas are derived from the HpPDA parameters, not fitted; there is no circularity problem. The examples are worked out in enough detail that a careful reader can locate exactly where the proof stops.\n\nWhere it falls: Section V, proof of condition (1). Equation (9) defines n raw shares via an n×n Cauchy matrix and proves that any m of them are non-perfect secret shares. The actual placement in (10)-(11) puts MDS-coded shares in each cache. A user sees m coded shares, which are linear combinations of the raw shares. For secrecy, one needs the key-coefficient matrix for every relevant selection of coded shares to be full rank. The paper neither states nor proves this. A Cauchy matrix alone doesn't help, because it is left-multiplied by an arbitrary MDS generator. The same gap appears in Theorem 2, where the sentence 'the number of coded shares of each file stored in each cache is Z' is treated as if Z coded shares inherit the non-perfect secrecy guarantee. They don't automatically. The t=K'-1 case in Section V-A also mixes raw and coded notation, which obscures rather than fixes the issue.\n\nA further soft spot, smaller but real: the baseline scheme is claimed to be 'trivially adapted' to hotplug, but the adaptation is never defined. The numerical outperformance claims in Section VII cannot be checked against a moving baseline. The lower bound used is for the classical K'-user system, which is fine as an absolute floor but doesn't pin down the baseline curve.\n\nOn balance, the construction is likely repairable: choose the MDS code so that every relevant set of output symbols satisfies the required full-rank condition, or design the placement so caches store raw shares. A rewrite could make this a solid subfield contribution for coded-caching researchers. As it stands, the main theorems are not proven. I would not reject the paper as hopeless, but I would not accept it in this form. If I were the editor, I would send it to a referee capable of checking the linear algebra, with a note that the secrecy proof needs to be redone for the actual cache contents.","headline":"First take on secrecy in hotplug caching, but the main theorems are unproven because the secrecy proof analyzes raw shares while caches hold MDS-coded shares.","tokens_in":19589,"tokens_out":3764,"would_cite":false,"duration_ms":48543,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["94A15","94A62","05B05"],"pacs":[],"model":"deepseek-v4-flash","headline":"Hotplug coded caching can be made secretive: two schemes built from HpPDAs give explicit memory-rate pairs and beat a baseline secretive scheme in low-memory regions.","keywords":["secretive coded caching","hotplug coded caching","placement delivery arrays","HpPDA","non-perfect secret sharing","MDS codes","t-designs","information-theoretic secrecy"],"falsifier":"Use Example 1's $(6,4,6)$ system: a file is split into 3 parts, mixed with 5 keys by an $8 \\times 8$ Cauchy matrix to make 8 shares, then expanded by a $(15,8)$ MDS code into 15 coded shares, and each user cache holds the 5 coded shares indexed by 2-subsets containing that user. Compute $I(W_i; Z_k)$ for one file and one cache; the paper's secrecy proof only covers the 8 pre-MDS shares, so a positive mutual information for the stored MDS-coded shares would refute condition (1), while a proof that the MDS submatrices are also full-rank on the key columns would confirm it.","tokens_in":18508,"feed_emoji":"🔒","tokens_out":10428,"duration_ms":111110,"temperature":0.7,"pith_summary":"Hotplug coded caching is the setting where the server knows that only $K'$ of $K$ users will be online during delivery, but not which ones. This paper asks whether that setting can also be secretive: no user should learn anything about any file from its cache, and an active user should learn nothing beyond the one file it requested, even after seeing all server transmissions. The paper claims yes for both known classes of Hotplug Placement Delivery Arrays (MAN-HpPDAs and t-design-based HpPDAs), and gives explicit memory-rate pairs, including $M = (N\\binom{K-1}{t-1} + \\binom{K-1}{t})/\\binom{K'-1}{t}$ and rate $R = \\binom{K'}{t+1}/\\binom{K'-1}{t}$ for the MAN-HpPDA scheme, with rate $1$ achievable at $t = K'-1$. Numerical comparisons for $(8,3,8)$ and $(12,3,12)$ systems show the new schemes beat a baseline secretive PDA scheme in certain low-memory regions. If correct, this extends information-theoretic secrecy to systems with intermittently present users without demanding a larger cache.","feed_headline":"Two schemes make offline-tolerant caching secretive","feed_subtitle":"Hotplug placement-delivery arrays plus secret sharing beat the baseline secretive scheme in low-memory regions.","key_machinery":"The load-bearing object is the Hotplug Placement Delivery Array (HpPDA): a pair $(P,B)$ in which $P$ is an $F \\times K$ array of stars and null entries, $B$ is a $[K',F',Z',S]$ PDA, and every choice of $K'$ active users has a subarray of $P$ that agrees with $B$ in its star positions. The MAN-HpPDA specialises this to rows indexed by all $t$-subsets of $[K]$, with stars encoding which user caches which share; the t-design construction obtains HpPDAs from combinatorial designs and supplies many memory points. Around this combinatorial skeleton the schemes wrap three coding ingredients: a non-perfect $(m,n)$ secret-sharing scheme (any $m$ shares leak nothing, all $n$ recover the file), a Cauchy matrix whose full-rank submatrices make the share generation a secure linear code, and an MDS code that expands $n$ shares into $F$ coded shares so that a user can recover enough shares from its cache plus the transmissions. Delivery messages are XORs of coded shares, each masked with a random key vector held only by the users that message is meant for; the $t=K'-1$ case needs no mask because every active user needs the single transmission.","core_discovery":"The paper's central claim is that secrecy can be layered onto hotplug coded caching without abandoning the placement-delivery-array machinery. Theorem 1 states that for any $(K,K',N)$ system and any $t \\in [0 : K'-2]$, a $(K,K',F,F',Z,Z',S)$ MAN-HpPDA gives a secretive scheme with memory $M = (N\\binom{K-1}{t-1} + \\binom{K-1}{t})/\\binom{K'-1}{t}$ and rate $R = S/(F'-Z')$, equal to $\\binom{K'}{t+1}/\\binom{K'-1}{t}$. Theorem 2 gives the analogous existence result for HpPDAs built from a $t$-$ (v,k,\\lambda)$ design, with memory $M = NZ/(F'-Z') + \\frac{1}{F'-Z'}\\sum_{s=1}^{t-2} a_s \\binom{K-1}{s}$ and rate $S/(F'-Z')$. In both schemes each file is split into parts and expanded through a non-perfect secret-sharing scheme, then through an MDS code into $F$ coded shares; caches hold shares whose row label contains the user's index plus random key vectors, and the server transmits XORs of requested coded shares masked by keys where needed. The proof of secrecy rests on the full-rank property of every submatrix of a Cauchy matrix: any $Z$ generated shares are claimed to be information-theoretically independent of the file because they are a full-rank linear combination of file parts and uniform keys.","pith_inferences":["A direct technical check left open by the paper is whether $m$ shares of the MDS-expanded coded shares are as uninformative as $m$ shares of the Cauchy-generated shares; one can settle it by verifying a full-rank condition on the MDS generator restricted to any $m$ output positions.","The complementary winning regions in the numerical curves suggest a hybrid scheme that chooses between MAN-HpPDAs, t-design HpPDAs, and the baseline PDA according to memory $M$; such a hybrid would likely dominate each individual curve, though the paper does not construct it.","Since the construction only requires a field of size $2^l \\ge 2n$ and works for any sufficiently large file, the same HpPDA-plus-secret-sharing template could be adapted to colluding-user secrecy or demand privacy by changing how the masking keys are generated."],"forward_implications":["Secrecy no longer requires all $K$ users to be online during delivery: the same HpPDA structure that makes hotplug caching work also supports information-theoretic secrecy.","At the parameter $t=K'-1$, the MAN-HpPDA scheme achieves rate $R=1$, which meets the lower bound from Lemma 1, so it is optimal at that memory point.","For an $(8,3,8)$ system, the MAN-based scheme beats the baseline for cache memory $M$ from 1 to 11.9, and the t-design scheme beats it from $M=10.4$ to 15.7; the new schemes fill complementary memory regions.","For a $(12,3,12)$ system, the t-design scheme beats the baseline across $M=1$ to 28.3, a wider winning region than the MAN-based scheme, giving designers a choice of which HpPDA class to instantiate."],"supporting_citations":[{"why":"Supplies the hotplug coded caching model: only $K'$ of $K$ users are active during delivery, and the server knows $K'$ but not which users.","marker":"[7]"},{"why":"Introduces HpPDAs and the MAN-HpPDA class whose parameters and placement structure Theorem 1 builds on.","marker":"[9]"},{"why":"Introduces the t-design construction of HpPDAs that Theorem 2 uses to obtain its memory-rate pairs.","marker":"[10]"},{"why":"Provides the baseline secretive coded caching scheme from PDAs that the paper adapts and compares against.","marker":"[15]"},{"why":"Gives the secrecy conditions, the lower bound used in Lemma 1, and the rate-one optimality benchmark.","marker":"[12]"},{"why":"Supplies the non-perfect secret sharing scheme used so that any $m$ shares leak nothing while all shares recover the file.","marker":"[23]"},{"why":"Supplies the Cauchy matrix whose full-rank submatrices carry the secrecy argument for the generated shares.","marker":"[24]"},{"why":"Defines the PDA framework underlying both the baseline scheme and the $B$ array inside an HpPDA.","marker":"[4]"}],"fun_headline_variants":["Secretive hotplug caching: two schemes beat baseline","Offline-tolerant caching made secretive with two schemes","Hotplug caching secrecy: two schemes outperform baseline","Secretive schemes for hotplug caching beat old method","Adding secrecy to hotplug coded caching: two wins"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The whole secrecy argument depends on the unproved assumption that the extra MDS coding step, applied after the Cauchy-matrix secret sharing, does not let a user's cached shares leak information about the file.","fun_headline_variants_meta":{"raw":{"variants":["Secretive hotplug caching: two schemes beat baseline","Offline-tolerant caching made secretive with two schemes","Hotplug caching secrecy: two schemes outperform baseline","Secretive schemes for hotplug caching beat old method","Adding secrecy to hotplug coded caching: two wins"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000579,"raw_usage":{"total_tokens":2773,"prompt_tokens":1031,"completion_tokens":1742,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":647,"completion_tokens_details":{"reasoning_tokens":1667}},"tokens_in":647,"tokens_out":1742,"duration_ms":14251,"temperature":1.0,"reasoning_tokens":1667,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T16:15:37.782193+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Use Example 1's $(6,4,6)$ system: a file is split into 3 parts, mixed with 5 keys by an $8 \\times 8$ Cauchy matrix to make 8 shares, then expanded by a $(15,8)$ MDS code into 15 coded shares, and each user cache holds the 5 coded shares indexed by 2-subsets containing that user. Compute $I(W_i; Z_k)$ for one file and one cache; the paper's secrecy proof only covers the 8 pre-MDS shares, so a positive mutual information for the stored MDS-coded shares would refute condition (1), while a proof that the MDS submatrices are also full-rank on the key columns would confirm it.","supporting_citations":[{"cited_title":"On coded caching systems with offl ine users,","cited_arxiv_id":null,"evidence_quote":"Supplies the hotplug coded caching model: only $K'$ of $K$ users are active during delivery, and the server knows $K'$ but not which users."},{"cited_title":"Improved Hotplug Caching Sche me Using PDAs,","cited_arxiv_id":null,"evidence_quote":"Introduces HpPDAs and the MAN-HpPDA class whose parameters and placement structure Theorem 1 builds on."},{"cited_title":"Improved Hotplug Caching Schemes Using PDAs and t-Designs","cited_arxiv_id":"2311.02856","evidence_quote":"Introduces the t-design construction of HpPDAs that Theorem 2 uses to obtain its memory-rate pairs."},{"cited_title":"Secretive Coded Caching from PDAs,","cited_arxiv_id":null,"evidence_quote":"Provides the baseline secretive coded caching scheme from PDAs that the paper adapts and compares against."},{"cited_title":"Private Coded Caching,","cited_arxiv_id":null,"evidence_quote":"Gives the secrecy conditions, the lower bound used in Lemma 1, and the rate-one optimality benchmark."},{"cited_title":"Cramer, I","cited_arxiv_id":null,"evidence_quote":"Supplies the non-perfect secret sharing scheme used so that any $m$ shares leak nothing while all shares recover the file."},{"cited_title":"Optimizing Cauchy Reed-Solomon C odes for Fault-Tolerant Network Storage Applications,","cited_arxiv_id":null,"evidence_quote":"Supplies the Cauchy matrix whose full-rank submatrices carry the secrecy argument for the generated shares."},{"cited_title":"On the placement de livery array design for centralized coded caching scheme,","cited_arxiv_id":null,"evidence_quote":"Defines the PDA framework underlying both the baseline scheme and the $B$ array inside an HpPDA."}],"review_version":1}