Prior-Guided Caching Theorem

• The paper’s main contribution shows that parsimonious querying with a limited prediction budget achieves near-logarithmic competitive ratios in online caching under both perfect and noisy predictions.
• It develops an information-theoretic framework where request priors optimize auxiliary variables to define precise rate regions for lossless recovery in cached systems.
• The theorem also spans popularity-based and derivation-constrained models, demonstrating that optimal cache strategies vary with predictive accuracy, access frequency, and reliability constraints.

Searching arXiv for the cited papers and closely related work. arXiv search query: (Im et al., 2022) Parsimonious Learning-Augmented Caching The expression Prior-Guided Caching Theorem is used in several arXiv contexts to denote caching results in which a prior, a predictor, or an access-frequency model shapes cache placement, delivery, or eviction decisions. In parsimonious learning-augmented caching, the prior consists of predicted next-arrival times that are queried only selectively, yielding competitive ratios that depend on both cache size and queried prediction error (Im et al., 2022). In information-theoretic caching for computing, the prior is a request distribution $p_Y$ that determines the optimal cached description through a single-letter rate region (Wang et al., 2015). In single-user average-case coded caching, the prior ranks files by request probability, and caching the most requested files is optimal (Wang et al., 2016). In premise-erasure caching for derivation-based reasoning, the prior is an access frequency over queries, and caching becomes optimal above a critical frequency threshold, with a derivation penalty that approaches $1/\epsilon$ under erasure (Xu, 1 Mar 2026).

1. Terminological scope and formal settings

The four uses of the expression share a common design principle: cache resources are allocated using statistical or predictive information about future demand. The formal objects, however, are different. In the online learning-augmented setting, the objective is to minimize cache misses against the offline optimum under adversarial request sequences. In the information-theoretic settings, the objective is to characterize optimal memory–rate regions or average delivery rates under a stochastic request law. In the derivation-based setting, the objective is to compare amortized storage cost against per-access derivation cost under erasure.

Setting	Guidance signal	Canonical guarantee
Learning-augmented online caching	Predicted next request times for queried pages	$$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$
Information-theoretic caching for computing	Request prior $p_Y$	$R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$
Single-user multiple-request caching	Popularity prior $p=(p_1,\dots,p_N)$	Top-$M$ most probable files are optimal
Premise-erasure caching	Access frequency $f(q)$ and erasure rate $\epsilon$	Cache if $f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$

This suggests that the term is best read as a family resemblance rather than a single canonical theorem. Across the four formulations, “prior-guided” refers respectively to adaptive prediction querying, source-coding optimization under a demand law, popularity-aware file selection, and thresholded caching under access-frequency and reliability models (Im et al., 2022, Wang et al., 2015, Wang et al., 2016, Xu, 1 Mar 2026).

2. Parsimonious learning-augmented caching

In "Parsimonious Learning-Augmented Caching" (Im et al., 2022), the request sequence is $1/\epsilon$0 over a universe $1/\epsilon$1, the cache capacity is $1/\epsilon$2, and the objective is to minimize the total number of misses. The offline benchmark is Belady’s furthest-in-future algorithm, with $1/\epsilon$3. A randomized online algorithm $1/\epsilon$4 is $1/\epsilon$5-competitive if

$1/\epsilon$6

where $1/\epsilon$7 is a $1/\epsilon$8-independent constant. The analysis uses the standard phase partition into maximal contiguous blocks requesting at most $1/\epsilon$9 distinct pages, together with marking. If $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$0 is the number of distinct clean pages in phase $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$1, then

$$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$2

which serves as a phase-wise proxy for $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$3 (Im et al., 2022).

The distinctive feature is parsimonious querying. At time $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$4, for any page $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$5 currently in cache, an oracle may return a prediction $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$6 of the next request time, with true next arrival $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$7. Rather than querying all pages in cache, the algorithm limits itself to at most $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$8 queried pages per miss. On a miss, it samples $$CR \le O(\min\{\log_{b+1} k + E[\eta]/opt,\log k\})$$9 unmarked pages uniformly at random without replacement, queries their predicted next-arrival times, and evicts the sampled page with the furthest predicted arrival. The total number of queries is $p_Y$0, with

$p_Y$1

and therefore, for fixed $p_Y$2, $p_Y$3 whenever $p_Y$4.

The main algorithm, AdaptiveQuery-$p_Y$5, combines marking with an eviction-chain decomposition. For each clean page $p_Y$6 in a phase, the associated chain is

$p_Y$7

where $p_Y$8 is the stale page evicted when serving the next request to $p_Y$9. If the current chain length satisfies $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$0, the algorithm uses predicted guidance on a sample of size $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$1; if $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$2, it switches to evicting an unmarked page uniformly at random, using no queries. The query budget per miss is therefore at most $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$3 in the predicted portion of a chain and zero thereafter.

The error model is defined only on queried predictions. The total $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$4 error is

$R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$5

where $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$6 is the set of queried page–time pairs. The analysis also counts inversions, namely queried pairs whose predicted order reverses the true order of next arrivals. If $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$7 is the number of such inversions, then

$R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$8

This stability relation allows bad evictions to be charged to prediction errors on the pages actually queried.

Under perfect predictions, the theorem states that for any integer $R_c \ge I(X;V|Y),\ R_u \ge H(f(X,Y)|V,Y)$9, AdaptiveQuery-$p=(p_1,\dots,p_N)$0 is

$p=(p_1,\dots,p_N)$1

and makes at most

$p=(p_1,\dots,p_N)$2

queries in expectation. Under noisy predictions, with the switch to randomized marking after chain length exceeds $p=(p_1,\dots,p_N)$3, the competitive ratio satisfies

$p=(p_1,\dots,p_N)$4

while still making at most $p=(p_1,\dots,p_N)$5 queries per cache miss. The proof is based on stale-page ranks, geometric rank decay under sampling, and an additive error term. If $p=(p_1,\dots,p_N)$6 is a uniform sample of $p=(p_1,\dots,p_N)$7 pages from $p=(p_1,\dots,p_N)$8 unmarked stale pages, then the minimum sampled rank satisfies

$p=(p_1,\dots,p_N)$9

which yields expected chain length at most $M$0 in the perfect-prediction case.

The lower bound is near-tight. For any integer $M$1, any $M$2-competitive algorithm under perfect predictions must make at least

$M$3

queries in expectation. This implies that constant-competitive behavior with sublinear querying cannot be sustained when the miss rate $M$4 is $M$5. The work is also positioned against learning-augmented caching schemes of Lykouris–Vassilvitskii, Rohatgi, and Wei: those schemes assume predictions for all pages in cache at each step, whereas the parsimonious algorithm queries only $M$6 pages per miss while retaining quantitatively similar guarantees (Im et al., 2022).

3. Information-theoretic prior-guided caching for computing

In "Information-Theoretic Caching: Sequential Coding for Computing" by Wang, Lim, and Gastpar (Wang et al., 2015), the prior-guided theorem is formulated for lossless computation from a discrete memoryless source $M$7 with finite alphabets and joint pmf $M$8. The request prior is $M$9. The per-letter desired data is an element-wise function $f(q)$0, and the goal is to reconstruct the sequence $f(q)$1. Caching is decomposed into a placement phase, in which a cache encoder observing $f(q)$2 sends a cache message $f(q)$3 at rate $f(q)$4, and a delivery phase, in which an update encoder observing $f(q)$5 sends an update message $f(q)$6 at rate $f(q)$7.

The single-user single-letter characterization is:

$f(q)$8

for some conditional pmf $f(q)$9 with $\epsilon$0. The cached description $\epsilon$1 is therefore chosen to minimize the expected delivery uncertainty about $\epsilon$2 given $\epsilon$3, subject to the cache-rate budget. The prior $\epsilon$4 enters directly through the optimization over $\epsilon$5.

Several boundary statements are explicit. The minimum update rate without caching is

$\epsilon$6

and the minimum cache rate without update is

$\epsilon$7

over $\epsilon$8 such that $\epsilon$9. The sum-rate lower bound is

$f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$0

If the function is partially invertible, in the sense that $f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$1, then

$f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$2

The paper gives closed-form solutions in several special cases. For independent source components with $f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$3 and $f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$4, the optimal region is

$f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$5

with $f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$6. The interpretation is that a popularity-first caching scheme is optimal for independent components. For nested components satisfying $f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$7, the region becomes

$f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$8

corresponding to a refinement-first strategy.

For arbitrarily correlated components under uniform requests, with $f(q)\cdot Dd(q\mid B)\ge \rho_s\cdot \sigma^*(q)$9 and conditional total correlation

$1/\epsilon$00

all boundary points satisfy

$1/\epsilon$01

If the cache rate is large enough to eliminate conditional total correlation, then for $1/\epsilon$02 the boundary is the straight line

$1/\epsilon$03

where

$1/\epsilon$04

For $1/\epsilon$05, $1/\epsilon$06 equals Wyner’s common information.

The same paper develops two-user extensions with single-letter characterizations linked to Gray–Wyner and distributed successive refinement. The private-update-aided Gray–Wyner system introduces a common cache $1/\epsilon$07 and private caches $1/\epsilon$08; the common-cache-aided Gray–Wyner system introduces a common update variable $1/\epsilon$09; and the sequential successive-refinement system derives a two-stage compute-and-refine region. The paper also compares this framework with the Maddah-Ali–Niesen model. In the single-user average case, the adaptive static-request region

$1/\epsilon$10

matches the single-user information-theoretic region, whereas a two-user example shows that coding across i.i.d. request blocks and coding within a single static block need not yield the same tradeoff (Wang et al., 2015).

4. Popularity-guided optimality in single-user multiple-request caching

"A New Converse Bound for Coded Caching" by Wang, Lim, and Gastpar (Wang et al., 2016) contains a distinct prior-guided theorem for the single-user average case with multiple requests. The model has $1/\epsilon$11 equal-sized files, a single user cache of size $1/\epsilon$12 files, and $1/\epsilon$13 file requests drawn independently with replacement according to a popularity distribution $1/\epsilon$14. Let

$1/\epsilon$15

be the set of distinct requested files, and let

$1/\epsilon$16

After rearranging so that $1/\epsilon$17, the optimal average delivery rate is

$1/\epsilon$18

It is achieved by caching the $1/\epsilon$19 most probable files, equivalently the files with the largest $1/\epsilon$20.

For integer cache size $1/\epsilon$21, the theorem simplifies to

$1/\epsilon$22

The significance of the result is that optimality holds among all feasible placements, including coded placements; in this single-user multiple-request average-case setting, uncoded top-$1/\epsilon$23 file caching is optimal.

The converse is formulated via a single-letter problem:

$1/\epsilon$24

where $1/\epsilon$25 is the binary representation of the files and $1/\epsilon$26 is a possibly coded cache content. By conditional entropy inequalities, data processing, Fano’s inequality, and the memory constraint, the paper derives the closed-form lower bound that matches the achievable top-$1/\epsilon$27 policy.

This theorem also feeds into a broader converse for multi-user coded caching. For a $1/\epsilon$28-user system with request prior $1/\epsilon$29, define

$1/\epsilon$30

Then

$1/\epsilon$31

Under uniform demand,

$1/\epsilon$32

Compared with the decentralized Maddah-Ali–Niesen scheme, the paper establishes a multiplicative gap smaller than $1/\epsilon$33 for both the worst case and the uniform-demand average case, improving previous analytical gaps of $1/\epsilon$34 and $1/\epsilon$35, respectively. The paper explicitly notes that the “most-popular is optimal” theorem does not directly generalize to the multi-user coded caching setting, where coded multicasting gains become central (Wang et al., 2016).

5. Prior-guided caching under premise erasure and derivation constraints

"The Derivation Penalty in Premise-Erasure Caching: Capacity, Strong Converse, and Dispersion Dichotomy" (Xu, 1 Mar 2026) develops a prior-guided theorem in a different direction, namely caching for derivation-based reasoning engines under independent premise erasure. The premise base $1/\epsilon$36 has size $1/\epsilon$37, each base fact is erased independently with probability $1/\epsilon$38, and a query $1/\epsilon$39 has derivation depth $1/\epsilon$40 and dependency count

$1/\epsilon$41

Two decoder models are compared. In the coded scheme, the cache is an arbitrary bit string. In the derivation-constrained scheme, the cache consists of logical facts and decoding must certify $1/\epsilon$42.

The paper states four coding theorems. The first establishes a universal per-step information content:

$1/\epsilon$43

with

$1/\epsilon$44

for generic queries in the information-rich regime. The second compares two Datalog architectures at equal depth. For the chain architecture,

$1/\epsilon$45

while for the balanced-merge architecture,

$1/\epsilon$46

Hence

$1/\epsilon$47

as $1/\epsilon$48.

The third theorem introduces a critical access frequency. With storage price per bit per access $1/\epsilon$49 and derivation cost $1/\epsilon$50 per step, the clean-base break-even frequency is

$1/\epsilon$51

The decision rule is to cache if $1/\epsilon$52 and derive on demand if $1/\epsilon$53. Under erasure and resilience target $1/\epsilon$54, the noisy refinement is

$1/\epsilon$55

where

$1/\epsilon$56

The fourth theorem gives the minimum derivation-constrained cache under erasure. For a generic query with $1/\epsilon$57 distinct dependencies, there exists a derivation-constrained cache using

$1/\epsilon$58

reliable bits, and any $1/\epsilon$59-resilient cache must satisfy

$1/\epsilon$60

The query information decomposes as

$1/\epsilon$61

For the coded scheme, the source–channel separation result is

$1/\epsilon$62

The resulting derivation penalty is

$1/\epsilon$63

as $1/\epsilon$64 with $1/\epsilon$65.

The proof-theoretic origin of the penalty is the structural caching rigidity theorem:

$1/\epsilon$66

Only cache facts inside the derivation DAG matter; off-DAG facts are irrelevant. The graph-theoretic corollary bounds the success probability by

$1/\epsilon$67

which rules out cross-coordinate error correction under derivation constraints.

The paper then states an explicit prior-guided decision rule. For a single query $1/\epsilon$68, cache if

$1/\epsilon$69

where $1/\epsilon$70 is either $1/\epsilon$71 or $1/\epsilon$72, depending on decoder class. For multi-query sets with overlap, replace $1/\epsilon$73 by the effective distinct dependency count $1/\epsilon$74. The framework also proves a strong converse at the KL-divergence rate with Bahadur–Rao prefactors, a dispersion dichotomy with positive coded dispersion and zero derivation-constrained dispersion, and an eight-regime phase diagram (Xu, 1 Mar 2026).

6. Comparative interpretation, robustness notions, and limitations

A central comparison across these results is the meaning of the word prior. In the learning-augmented theorem, the prior is operationalized as predicted next-arrival times queried on demand. In the sequential coding theorem, it is a request law $1/\epsilon$75 used to optimize an auxiliary variable $1/\epsilon$76. In the single-user multiple-request theorem, it is a popularity ranking summarized by $1/\epsilon$77. In the derivation-based theorem, it is an access frequency $1/\epsilon$78 entering a storage-versus-computation inequality. A plausible implication is that “prior-guided” is not a single technical mechanism but a recurrent design pattern in which side information about future use changes the optimal cache policy (Im et al., 2022, Wang et al., 2015, Wang et al., 2016, Xu, 1 Mar 2026).

The robustness guarantees are likewise non-uniform. The learning-augmented theorem is robust in competitive-ratio terms, defaulting to $1/\epsilon$79 when queried predictions are inaccurate. The information-theoretic theorem is exact at the level of the rate region but assumes a known source law and lossless recovery. The popularity theorem is exact for the single-user multiple-request average case, but the paper explicitly states that it does not directly generalize to the multi-user coded caching setting. The derivation-based theorem is robust in a different sense: it compares decoder classes under erasure, proves a strong converse, and identifies a universal asymptotic penalty for derivation-constrained storage.

Several recurring misconceptions are clarified by juxtaposing the results. One possible confusion is to identify prior-guided caching with “cache the most popular files.” That statement is exact only in the single-user multiple-request model (Wang et al., 2016). Another is to read parsimony as a statement about cache size rather than about how many predictions are queried; in the learning-augmented theorem, parsimony refers to the fact that at most $1/\epsilon$80 pages are queried per miss (Im et al., 2022). A third is to assume that all uses of a prior produce the same objective function. The information-theoretic theorem optimizes $1/\epsilon$81 under a mutual-information constraint (Wang et al., 2015), whereas the derivation-based theorem compares $1/\epsilon$82 with $1/\epsilon$83 (Xu, 1 Mar 2026).

Taken together, the results delineate a broad research program. Priors can be used to choose which pages to query, which representation to cache, which files to store, or whether to cache at all. The mathematical consequences depend on the ambient model: competitive analysis for online caching, single-letter regions for distributed source coding, entropy-based lower bounds for coded caching, or capacity and strong-converse statements for reasoning systems under erasure. This suggests that the enduring content of the Prior-Guided Caching Theorem is methodological: cache design improves when the cache controller is allowed to exploit structured information about future demand, but the formal theorem is model-specific rather than universal.