{"id":"b3c2c5dc-6cf1-4b41-966a-9bf4c9c7becf","arxiv_id":"2507.00727","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":1,"one_line_summary":"A new array construction, HHPDA, extends coded caching with offline users to hierarchical networks where mirrors also have caches.","lead":"This paper builds a bookkeeping tool for delivering cached video in a two-tier network when some users are offline. It defines a new array, the HHPDA, that coordinates what the server and mirrors store and send, and it constructs examples from combinatorial designs.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The t-design construction does not always produce a valid HHPDA: Appendix B's A3 uniqueness proof is false when the design has λ>1, because the same set A\\{i} can appear in two different mirror subarrays.","rationale":"The central claim has two parts: HHPDA schemes via Algorithm 1 (Theorem 1) and the t-design construction (Theorem 2). Theorem 1 appears sound given the HHPDA conditions: the cancellation in Appendix A follows from PDA condition C3 together with A3/A4 of Definition 6. The real soft spot is Theorem 2. Its proof that every integer occurs exactly once in Q is wrong when the design has λ>1; duplicate labels across mirror subarrays are then unavoidable and violate A3 under the paper's own definition. The paper's Example 4 uses a Steiner 3-(8,4,1) design, where unique block containment of every 3-subset masks this failure, so the error is easy to miss. Because a simple relabeling with mirror indices repairs the construction without changing the stated per-mirror cardinalities or the load formulas, the result should remain CONDITIONAL rather than REJECT. The reader's stated weakest assumption was condition (1), but their rationale also flags the A3 uniqueness argument as false; I agree with that narrower diagnosis and consider it the load-bearing issue.","tokens_in":16291,"tokens_out":24056,"duration_ms":283181,"concrete_test":"Instantiate the construction of Theorem 2 with the complete 2-(6,3,4) design, K2=1, t=2 and a1=6 (so F'=12 and |R|=12>λ1=10), and enumerate the entries q_{A,i}=A\\{i} of Q. The blocks A={1,2,3} and A'={2,3,4} yield the same label {2,3} in columns 1 and 4. Converting set labels to integers as the paper describes (\"replace different sets by different integers\") therefore gives one integer occurring in two different mirror subarrays, so Definition 6(A3) is violated. This is a direct algebraic check of the claimed HHPDA property and needs no simulation.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Theorem 2's proof of condition A3 in Appendix B is the load-bearing weak point, not the t-design projection behind condition (1). The proof asserts that an equality A\\{i}=A'\\{i'} forces i=i', because \"if i≠i', equality in (6) is not possible.\" This is false. In the complete 2-(6,3,4) design (all 3-subsets of [6]), the blocks A={1,2,3} and A'={2,3,4} satisfy A\\{1}={2,3}=A'\\{4}. With K2=1, mirror groups are singleton points, so the same set label {2,3} is a symbol appearing in Q(1) and Q(4). Definition 6(A3) requires each integer s∈S_{k1} to occur in exactly the subarray Q(k1); a symbol in two different mirror subarrays belongs to both S1 and S4 and cannot satisfy A3. Hence the claimed HHPDA from Theorem 2 is not always a valid HHPDA as defined. The construction can be repaired by prefixing each label with its mirror index, e.g. (k1, A\\{i}), which keeps |S_{k1}| and the loads of Theorem 2 unchanged, or by restricting to λ=1 Steiner designs; neither repair appears in the paper. The projection/condition (1) argument is likely sound, since [16] supplies blocks with the required exact intersections.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper considers a two-layer hierarchical coded caching network in which only K' of the K1K2 users are active during delivery. It introduces a combinatorial object called a hierarchical hotplug placement delivery array (HHPDA), which is meant to describe both placement and delivery for such a system with nonzero mirror caches. Theorem 1 (with Algorithm 1 and Appendix A) claims that any HHPDA yields a hotplug hierarchical coded caching scheme with specified memory ratios and loads. Section V constructs a family of HHPDAs from t-designs, and Theorem 2 (proved in Appendix B) gives their parameters. The paper positions this as the first general treatment of hotplug hierarchical caching with mirror caches, extending the zero-mirror-cache scheme of [24].","tokens_in":16561,"tokens_out":14893,"duration_ms":155008,"significance":"If sound, the HHPDA framework is a useful unification of hierarchical and hotplug coded caching, and the t-design construction would provide concrete schemes with nonzero mirror memory and flexible subpacketization. The definition of HHPDA and the derivation of the caching scheme in Theorem 1 are coherent, and the worked examples are helpful. The main construction, however, relies on a uniqueness claim in Appendix B that is false for designs with lambda > 1; as written, the array produced in Section V is not always an HHPDA. The flaw is local and likely repairable by prefixing each set label with its mirror index, but the proof of Theorem 2 is currently incomplete.","major_comments":[{"comment":"The assertion that 'if i != i', then equality in (6) is not possible' is false. For the complete 2-(6,3,4) design with K1=6 and K2=1 (so each mirror group is a singleton), the blocks A={1,2,3} and A'={2,3,4} satisfy A\\{1} = A'\\{4} = {2,3}. Under Eq. (4), this same set-valued entry appears in the subarrays Q(1) and Q(4), so it belongs to both S1 and S4. Definition 6(A3) requires each integer s in S_{k1} to occur exactly in the subarray Q(k1); a symbol in two different mirror subarrays cannot satisfy this. Therefore the array constructed in Section V is not always an HHPDA, and Theorem 2 is not proved for lambda > 1. The construction can be repaired by relabeling each entry as (k1, A\\{i}) or by assigning disjoint integer ranges to the different mirrors; this repair leaves |S_{k1}| and the loads of Theorem 2 unchanged, but it is not stated in the paper.","section":"Appendix B, proof of A3, Eq. (6)"},{"comment":"The construction defines entries of Q(k1) as the sets A\\{i}, but Definition 6 requires entries to be integers from pairwise disjoint sets S_{k1}. The only guidance given is in Example 4, which says to replace different sets by different integers; that instruction maps equal sets to equal integers and therefore does not prevent cross-mirror collisions when lambda > 1. The proof of A3 is the only place where uniqueness is addressed, and it is incorrect. The authors should specify the relabeling explicitly (e.g., a bijection from the pairs (k1, A\\{i}) to integers) and then prove A3 for that relabeling, rather than treating the set-valued entries themselves as the final integers.","section":"Section V, construction around Eqs. (3)-(4)"}],"minor_comments":[{"comment":"The MDS code parameters are written inconsistently: the text says a '[9, 14] MDS code' and later a '[7, 14] MDS code'. Since F=14 and F'=9, the code should be a [14,9] MDS code (or, in the notation of Algorithm 1, an [F,F'] code).","section":"Example 3"},{"comment":"The construction states 'Let K2 be an integer such that K2 < t', but Theorem 2 states K2 <= t. If K2 = t is allowed, the proof of A1 and A2 should be checked at this boundary case; otherwise the theorem statement should be aligned with the construction.","section":"Section V and Theorem 2"},{"comment":"The sentence 'consider the row indices f' in zeta of the Z1 rows in which stars appear such that q^(0)_{f',k1} = star' is confusing: the set of such rows need not have size Z1 after restriction to zeta, and not every star of B is necessarily a mirror-cache star. The proof should clarify that rows whose B-star comes from the user cache are already available to the user, so only the mirror-star rows with integer labels in S_{k1} require the second set of mirror transmissions.","section":"Appendix A, proof of Theorem 1"},{"comment":"The wording 'Each integer s in S_{k1} occurs in exactly the subarray Q(k1)' would be clearer as 'does not occur in Q(k1') for any k1' != k1', and no integer from another S_{k1'} occurs in Q(k1)'; the current phrasing leaves the disjointness of the S_{k1} implicit.","section":"Definition 6, condition A3"}],"recommendation":"major_revision","confidential_remarks":"The paper's main construction depends heavily on the companion preprint [16] for the HpPDA property used in the proof of condition (1). The authors should be asked either to prove that property self-contained or to cite the precise theorem number in [16]. The A3 flaw is fixable and should not require a change to the HHPDA definition; if the authors prefer, they could restrict Theorem 2 to lambda = 1 designs, but the paper's stated scope is broader. The paper is otherwise clearly written and suitable in scope for an information theory journal once the repair is made."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Read the arXiv paper. Short version: the HHPDA framework is a real and useful unification of two strands of work, and Algorithm 1 is coherent. But the t-design construction in Theorem 2 has a load-bearing proof error in Appendix B that should be fixed before acceptance.\n\nWhat's new and good: Definition 6 combines the hierarchical star condition (Q(0)) with a hotplug PDA B and a per-mirror symbol condition. The reduction in Theorem 1, an HHPDA gives a two-layer hotplug scheme via MDS-coded placement, is plausible and the example in Section IV checks out. This genuinely extends [24], which only handled zero mirror caches, and it puts the problem in the same PDA language the community already uses. The t-design construction is a natural continuation of [16], and the parameters in Theorem 2 are clean.\n\nThe soft spot is real. The A3 proof in Appendix B says that if A\\{i}=A'\\{i'} and i != i', equality in (6) is impossible. That is false. In the complete 2-(6,3,4) design, take A={1,2,3} and A'={2,3,4}; then A\\{1}=A'\\{4}. Nothing prevents this when lambda > 1. If K2=1, so each mirror group is a single point, the same label {2,3} appears in Q(1) and Q(4), which violates A3's requirement that each integer occurs in exactly one subarray. The construction as stated therefore does not always produce an HHPDA. The fix is local: prefix each label with its mirror index, e.g. (k1, A\\{i}), which does not change any of the parameter counts, or restrict to lambda=1 Steiner designs. The paper does not mention either repair. I believe condition (1), the hotplug projection, is on firmer ground because it piggybacks on the HpPDA construction in [16]; the flaw is specifically the global uniqueness claim for Q's non-star entries.\n\nMinor issues: Example 3 writes '[9,14] MDS' and later '[7,14]' where it should be an [14,9] MDS code. Notation around S_{k1} could be clearer. None of that changes the verdict.\n\nIs it serious? Yes. The framework is a decent contribution, the proof of Theorem 1 looks sound, and the construction is probably salvageable with a small patch. The citation pattern is fine; the dependency on [16] is a reduction, not a circular derivation.\n\nRecommendation: send to peer review, but ask for a major revision focused on the A3 proof. If the repair is as simple as mirror-prefixing, the result will be worth publishing. The paper is for the coded caching / combinatorial-design subcommunity, and they will care about this exact issue.","headline":"HHPDA framework is a solid unification, but the t-design construction's A3 uniqueness proof is false for lambda > 1 and needs a localized fix.","tokens_in":17127,"tokens_out":3546,"would_cite":false,"duration_ms":36942,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper proves that a hierarchical hotplug placement delivery array (HHPDA) yields a complete two-layer coded caching scheme with offline users, and that t-designs build such arrays.","keywords":["coded caching with offline users","hierarchical coded caching","hotplug coded caching","placement delivery array","combinatorial t-designs","MDS codes"],"falsifier":"Take a small instance of the construction, such as the $3$\\text{-}$(8,4,1)$ design used in the paper's example, and enumerate all $\\binom{8}{3}=56$ possible active-user sets; for each set, compute the array $Q'_{\\zeta,\\tau}$ for every row subset $\\zeta$ of size $F'=9$ and check whether it matches $B$ in star positions. If any active-user set admits no such $\\zeta$, the claimed theorem fails for that design.","tokens_in":16066,"feed_emoji":"📡","tokens_out":8356,"duration_ms":84068,"temperature":0.7,"pith_summary":"This paper is about delivering cached files over a two-layer network—a server, mirror sites with caches, and users with caches—when some users are offline when delivery starts. The authors propose a combinatorial object, the hierarchical hotplug placement delivery array (HHPDA), that bundles the cache-filling pattern and the transmission pattern into one array, and they prove that any HHPDA yields a complete hotplug hierarchical coded caching scheme. They then show that combinatorial t-designs supply a whole family of HHPDAs, giving explicit memory ratios and transmission loads on both layers. The point is to take the previously studied hotplug hierarchical setting, which only worked when every mirror cache had zero memory, and extend it to mirrors that actually store content.","feed_headline":"New array extends hotplug caching to two-layer networks","feed_subtitle":"t-designs give explicit memory ratios and loads, with mirror caches that can store data.","key_machinery":"The load-bearing object is the HHPDA $(Q,B)$, where $Q$ is a two-layer array and $B$ is a single-layer PDA. Its defining projection condition—for every active-user set $\\tau$ with $|\\tau|=K'$, a row subset $\\zeta$ exists with $Q'_{\\zeta,\\tau} \\stackrel{\\star}{=} B$—is what certifies that every active user can cancel interference during delivery. In the t-design construction, block membership in a $t$-$(v,k,\\lambda)$ design generates the stars: a mirror column gets a star when a group $D_{k_1}$ is contained in a block, and user entries get stars or integers from the block's remaining points. The array $B$ is produced by a prior t-design hotplug PDA construction, and an $[F,F']$ MDS code converts the $F'$ subpackets of every file into the $F$ coded packets that fill caches and travel in XOR messages.","core_discovery":"The paper's central claim is that a single array object, the hierarchical hotplug placement delivery array (HHPDA), completely describes both phases of a hotplug hierarchical coded caching scheme: an $F \\times (K_1 + K_1 K_2)$ array $Q$ with a mirror part $Q^{(0)}$ and per-mirror user parts $Q^{(k_1)}$, together with an $F' \\times K'$ placement delivery array $B$. The defining condition (1) requires that for every possible set $\\tau$ of $K'$ active users there is a row subset $\\zeta \\subseteq [F]$ such that the projected star pattern $Q'_{\\zeta,\\tau}$ matches $B$ in star positions. Given such a pair, Algorithm 1 produces a $(K_1,K_2,K'; M_1,M_2;N)$ hotplug hierarchical scheme with subpacketization $F'$, memory ratios $M_1/N = Z_1/F'$ and $M_2/N = Z_2/F'$, first-layer load $R_1 = |S|/F'$, and second-layer load $R_2$ expressed through the sets $S(j)$ and $S^{(k_2,\\zeta)}_{k_1}$. The paper further claims that every $t$-$(v,k,\\lambda)$ design with non-repeated blocks yields such an HHPDA with $K' = t$ and $K_2 \\le t$, giving explicit caches and loads as in Corollary 2. This removes the zero-mirror-memory restriction of earlier hotplug hierarchical schemes.","pith_inferences":["A direct stress test of the construction would be to enumerate every active-user set for a small t-design and verify Condition (1) row by row; the paper proves the condition in general but does not tabulate this check for its examples.","The second-layer load formula suggests that the worst-case choice of which users are offline may make one mirror the bottleneck; comparing $R_2$ across active-user distributions would quantify how robust the scheme is to offline patterns.","Because the construction forces $K'=t$ and $K_2\\le t$, extending the same idea to arbitrary $K'$ or to more than two layers would require a different combinatorial engine, such as covering arrays or product constructions rather than t-designs."],"forward_implications":["Every valid HHPDA produces a working hotplug hierarchical scheme with the stated memory ratios and loads, so the array object is a complete design tool rather than a special example.","Any $t$-$(v,k,\\lambda)$ design with non-repeated blocks gives a concrete scheme with $K'=t$, $K_2\\le t$, $M_1/N=\\lambda_{K_2}/F'$, and $M_2/N=(\\lambda-\\lambda_{K_2})/F'$.","Because only the number $K'$ of active users must be known during placement, not their identities, the scheme covers the offline-user scenarios that break ordinary hierarchical coded caching.","Setting $Z_1=0$ in an HHPDA yields the earlier zero-mirror-cache hotplug hierarchical scheme, showing the new definition generalizes that case."],"supporting_citations":[{"why":"Supplies the t-design hotplug PDA construction used for B and the projection argument reused in Theorem 2.","marker":"[16]"},{"why":"Defines HpPDA, the single-layer hotplug array that HHPDA generalizes.","marker":"[15]"},{"why":"Defines HPDA for two-layer networks without offline users; HHPDA extends this structure.","marker":"[20]"},{"why":"Proposes the zero-mirror-cache hotplug hierarchical scheme that the new construction generalizes.","marker":"[24]"},{"why":"MDS codes are used in Algorithm 1 to encode F' packets into F coded packets for cache filling.","marker":"[25]"},{"why":"Provides the t-design lemmas that compute star counts and block counts in the construction.","marker":"[26]"}],"fun_headline_variants":["Hotplug caching gets two-layer array for offline users","New array removes zero-mirror limit in hierarchical caching","t-designs build HHPDA for two-layer hotplug caching","Offline users included in hierarchical coded caching scheme"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is Condition (1): no matter which $K'$ users turn out to be active, the projected star pattern of the big array must exactly match the fixed small PDA $B$; if even one active-user set lacks such a row subset, the delivery phase has no certificate that users can cancel interference.","fun_headline_variants_meta":{"raw":{"variants":["Hotplug caching gets two-layer array for offline users","New array removes zero-mirror limit in hierarchical caching","t-designs build HHPDA for two-layer hotplug caching","Offline users included in hierarchical coded caching scheme"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000235,"raw_usage":{"total_tokens":1525,"prompt_tokens":994,"completion_tokens":531,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":610,"completion_tokens_details":{"reasoning_tokens":465}},"tokens_in":610,"tokens_out":531,"duration_ms":5465,"temperature":1.0,"reasoning_tokens":465,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T21:11:52.021847+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a small instance of the construction, such as the $3$\\text{-}$(8,4,1)$ design used in the paper's example, and enumerate all $\\binom{8}{3}=56$ possible active-user sets; for each set, compute the array $Q'_{\\zeta,\\tau}$ for every row subset $\\zeta$ of size $F'=9$ and check whether it matches $B$ in star positions. If any active-user set admits no such $\\zeta$, the claimed theorem fails for that design.","supporting_citations":[{"cited_title":"Improved Hotplug Caching Sch eme Using PDAs,","cited_arxiv_id":null,"evidence_quote":"Defines HpPDA, the single-layer hotplug array that HHPDA generalizes."},{"cited_title":"Combinatorial Designs for C oded Caching on Hierarchical Networks,","cited_arxiv_id":null,"evidence_quote":"Defines HPDA for two-layer networks without offline users; HHPDA extends this structure."},{"cited_title":"Hierarchical Ca ching System with Hotplug Model Using HpPDA,","cited_arxiv_id":null,"evidence_quote":"Proposes the zero-mirror-cache hotplug hierarchical scheme that the new construction generalizes."},{"cited_title":"Coding theory: a first course,","cited_arxiv_id":null,"evidence_quote":"MDS codes are used in Algorithm 1 to encode F' packets into F coded packets for cache filling."},{"cited_title":"Combinatorial designs: cons tructions and analysis","cited_arxiv_id":null,"evidence_quote":"Provides the t-design lemmas that compute star counts and block counts in the construction."}],"review_version":1}