Oblivious Update Problem in Storage and Graphs

• The Oblivious Update Problem is a framework where update metadata is absent, affecting both distributed storage and dynamic graph algorithms.
• In distributed storage, oblivious updates require downloading at least 2log₂q bits per helper to correctly update stale nodes under linear encoding.
• In dynamic graph algorithms, the adversarial model of oblivious updates leads to exponential gaps in update complexity between robust and non-robust methods.

The oblivious update problem denotes a family of update tasks in which the entity being refreshed or maintained does not receive explicit metadata identifying the change. In distributed storage, the canonical formulation asks how an offline stale node can transform its coded contents from $G_s \boldsymbol m$ to $G_s \boldsymbol m'$ after the underlying message changes, even though neither the stale node nor the updated helpers know which symbol changed or what its old or new value is (Nakkiran et al., 2014). In dynamic graph algorithms, the same phrase is directly relevant to the distinction between update sequences fixed independently of the algorithm’s randomness and outputs and update sequences chosen adaptively from prior outputs; the resulting gap determines whether obliviousness of updates can fundamentally reduce achievable update complexity (Bernstein et al., 23 Oct 2025). An entanglement-assisted extension of the storage setting further shows that pre-shared quantum entanglement among helpers changes the communication optimum for MDS-coded oblivious updates (Dubey, 19 May 2026).

1. Terminology and scope

The term “oblivious” is used in two technically distinct ways.

Setting	Meaning of obliviousness	Primary complexity measure
Distributed storage	No node stores any log of modifications; neither the stale node nor the updated nodes know the location or magnitude of the change	Total downloaded communication, measured in bits
Dynamic graph algorithms	The whole update sequence is independent of the algorithm’s randomness and outputs	Total or amortized update time

In distributed storage, obliviousness is a missing-metadata constraint. A stale node knows only its stale coded symbols and the code; updated helpers know only their own current coded symbols and the code. The central quantity is the minimum communication needed to update exactly under the promise that at most one message symbol changed (Nakkiran et al., 2014).

In dynamic graph algorithms, obliviousness is an adversarial model. The 2025 graph-theoretic formulation distinguishes robust algorithms, which remain correct when updates are chosen based on past behavior, from non-robust algorithms, which are guaranteed only when the entire update sequence is independent of the algorithm’s randomness and outputs. This distinction is studied in standard incremental and decremental graph models and is shown to yield exponential separations for natural graph problems with explicit input (Bernstein et al., 23 Oct 2025).

This suggests that “oblivious update problem” is best understood as a common structural theme rather than a single formal problem: update identity is unavailable to the maintainer, either because no change log exists or because future updates cannot adapt to the algorithm’s revealed state.

2. Classical distributed-storage formulation

In the storage formulation, a message $\boldsymbol m \in (\mathbb F_q)^B$ is distributed across $n$ nodes using a linear storage code. Node $\ell$ stores

$G_\ell \boldsymbol m,$

where $G_\ell$ is an $A \times B$ matrix. If node $s$ goes offline and the message changes to $\boldsymbol m'$, the stale node retains $G_s \boldsymbol m'$0 and must update to $G_s \boldsymbol m'$1. The model studied in the classical paper assumes

$G_s \boldsymbol m'$2

so at most one message symbol is modified (Nakkiran et al., 2014).

The obliviousness requirement is strict. No node stores any log of modifications; the stale node does not know which symbol changed; the updated nodes do not know which symbol changed; the updated nodes do not know the old value; the stale node does not know the new value; and neither side knows the location or magnitude of the change. The only side information explicitly assumed in the problem is that all parties know the code, and the stale node knows that at most one symbol has changed (Nakkiran et al., 2014).

Two code classes are analyzed. For arbitrary linear storage codes, only the encoding is required to be linear, while update protocols may be linear or nonlinear. For linear MDS codes, the message is recoverable from any $G_s \boldsymbol m'$3 nodes and each node stores the minimum possible

$G_s \boldsymbol m'$4

The first converse is a generic lower bound under extremely weak conditions. Even if a genie provides all updated nodes with the entire updated message and the stale node with the entire stale message, and even if the stale node can contact arbitrarily many updated nodes, any exact oblivious update under linear encoding requires total download at least

$G_s \boldsymbol m'$5

bits. The proof collapses all helpers into a single super-helper sending a function $G_s \boldsymbol m'$6, then uses a pigeonhole argument over $G_s \boldsymbol m'$7 candidate updated messages of the form $G_s \boldsymbol m'$8. If the message alphabet of $G_s \boldsymbol m'$9 had size below $\boldsymbol m \in (\mathbb F_q)^B$0, two distinct candidate updates would become indistinguishable to the stale node even though they induce different updated stale contents. The lower bound therefore isolates an intrinsic information-theoretic cost of obliviousness rather than an artifact of locality or weak protocols (Nakkiran et al., 2014).

For linear MDS codes, the converse is sharper. A stale node must contact at least $\boldsymbol m \in (\mathbb F_q)^B$1 updated nodes, and when it contacts exactly $\boldsymbol m \in (\mathbb F_q)^B$2 updated nodes it must download at least

$\boldsymbol m \in (\mathbb F_q)^B$3

bits from each of them. In the formulation stated in the paper, fewer than $\boldsymbol m \in (\mathbb F_q)^B$4 helpers cannot suffice because the stale node cannot distinguish “no update happened” from “a single-symbol update happened” when only $\boldsymbol m \in (\mathbb F_q)^B$5 updated nodes are available; moreover, each of the $\boldsymbol m \in (\mathbb F_q)^B$6 helpers must have at least $\boldsymbol m \in (\mathbb F_q)^B$7 distinguishable outputs, which again yields the $\boldsymbol m \in (\mathbb F_q)^B$8 per-helper bound (Nakkiran et al., 2014).

3. Optimal classical constructions and capacity characterization

The classical paper gives matching achievability results for both code classes, thereby characterizing the communication cost of oblivious updates under its assumptions (Nakkiran et al., 2014).

For arbitrary linear storage codes, the construction is based on the product-matrix MBR framework. An auxiliary parameter $\boldsymbol m \in (\mathbb F_q)^B$9 is introduced so that the full message can be recovered from any $n$0 nodes. Assuming

$n$1

is an integer, the message is partitioned into $n$2 groups, each embedded into a symmetric matrix $n$3 of size $n$4 whose bottom-right $n$5 submatrix is zero. Node $n$6 stores the collection

$n$7

with vectors $n$8 and scalars $n$9 chosen so that appropriate full-rank and ratio-uniqueness conditions hold.

If node $\ell$0 is stale, it contacts any two updated nodes $\ell$1. Updated node $\ell$2 returns the single field symbol

$\ell$3

Using its stale contents, node $\ell$4 subtracts the corresponding stale quantities and forms differences $\ell$5. If the single modified symbol lies in position $\ell$6 of matrix $\ell$7 and changes by $\ell$8, then

$\ell$9

When both are zero, nothing affecting node $G_\ell \boldsymbol m,$0 changed. Otherwise, the ratio

$G_\ell \boldsymbol m,$1

uniquely identifies the changed location $G_\ell \boldsymbol m,$2, after which $G_\ell \boldsymbol m,$3 is recovered from one absolute value and the stale stored block is updated accordingly. The total download is exactly two field elements, i.e.

$G_\ell \boldsymbol m,$4

matching the generic lower bound (Nakkiran et al., 2014).

For linear MDS codes, the achievability result also matches the converse exactly. Let

$G_\ell \boldsymbol m,$5

Choose an $G_\ell \boldsymbol m,$6 matrix $G_\ell \boldsymbol m,$7 such that every submatrix of $G_\ell \boldsymbol m,$8 is full rank, and partition $G_\ell \boldsymbol m,$9 into node blocks $G_\ell$0. Node $G_\ell$1 stores

$G_\ell$2

If node $G_\ell$3 is stale, it contacts any $G_\ell$4 updated nodes $G_\ell$5. For $G_\ell$6, vectors $G_\ell$7 are defined by

$G_\ell$8

where $G_\ell$9 and $A \times B$0 are the first two rows of $A \times B$1. Updated node $A \times B$2 returns

$A \times B$3

Summing across helpers reconstructs $A \times B$4 and $A \times B$5. The stale node compares these with its stale values, obtains two differences $A \times B$6, identifies the changed coordinate from the ratio $A \times B$7, recovers the additive change $A \times B$8, and updates $A \times B$9 to $s$0. Each helper sends exactly two field symbols, so the scheme contacts any $s$1 helpers and downloads exactly $s$2 bits from each, matching the MDS converse (Nakkiran et al., 2014).

The capacity interpretation in the paper is therefore exact: for arbitrary linear storage codes, the minimum total download is $s$3; for linear MDS codes, the stale node must contact at least $s$4 updated nodes and download at least $s$5 bits from each, and both bounds are achieved. A qualitative conclusion drawn in the paper is that stronger storage symmetry through the MDS constraint imposes a higher communication cost for oblivious updates (Nakkiran et al., 2014).

4. Entanglement-assisted oblivious updates

The 2026 quantum extension studies the same MDS-coded storage setting with file size

$s$6

per-node storage $s$7, and exactly $s$8 contacted helpers, but allows the helpers to share prior quantum entanglement (Dubey, 19 May 2026). Node $s$9 stores

$\boldsymbol m'$0

and the MDS property requires that for any $\boldsymbol m'$1 nodes $\boldsymbol m'$2, the stacked matrix

$\boldsymbol m'$3

is invertible.

The update model remains the standard oblivious one: either $\boldsymbol m'$4 or

$\boldsymbol m'$5

and neither the stale node nor the helpers know the changed coordinate $\boldsymbol m'$6 or update value $\boldsymbol m'$7. The communication model changes: before any update, the $\boldsymbol m'$8 helpers share an entangled state

$\boldsymbol m'$9

Each helper applies a local quantum encoding depending only on its own updated classical data and transmits the resulting quantum system to the stale node, which performs a joint measurement using its side information $G_s \boldsymbol m'$00. Bandwidth is measured in bits-equivalent: if each helper sends $G_s \boldsymbol m'$01 qudits of dimension $G_s \boldsymbol m'$02, then

$G_s \boldsymbol m'$03

The main theorem states that, for sufficiently large prime $G_s \boldsymbol m'$04 satisfying

$G_s \boldsymbol m'$05

the optimal entanglement-assisted update bandwidth is

$G_s \boldsymbol m'$06

bits-equivalent. For even $G_s \boldsymbol m'$07, this is exactly half the classical lower bound

$G_s \boldsymbol m'$08

for odd $G_s \boldsymbol m'$09, the ratio is

$G_s \boldsymbol m'$10

which approaches $G_s \boldsymbol m'$11 as $G_s \boldsymbol m'$12 (Dubey, 19 May 2026).

Achievability is based on CSS stabilizer codes. In the special case $G_s \boldsymbol m'$13, the paper uses a $G_s \boldsymbol m'$14 CSS code with parity checks $G_s \boldsymbol m'$15 satisfying

$G_s \boldsymbol m'$16

and with every coordinate of $G_s \boldsymbol m'$17 and $G_s \boldsymbol m'$18 nonzero. Writing

$G_s \boldsymbol m'$19

and letting helper $G_s \boldsymbol m'$20 store $G_s \boldsymbol m'$21, each helper transmits one qudit after applying

$G_s \boldsymbol m'$22

where

$G_s \boldsymbol m'$23

A joint stabilizer measurement yields syndromes

$G_s \boldsymbol m'$24

so the stale node recovers $G_s \boldsymbol m'$25 exactly using bandwidth $G_s \boldsymbol m'$26 bits-equivalent (Dubey, 19 May 2026).

For general $G_s \boldsymbol m'$27, the code parameters become

$G_s \boldsymbol m'$28

With $G_s \boldsymbol m'$29, each helper controls $G_s \boldsymbol m'$30 qudits. The construction chooses $G_s \boldsymbol m'$31 as a Vandermonde matrix and $G_s \boldsymbol m'$32 with rows in $G_s \boldsymbol m'$33 so that

$G_s \boldsymbol m'$34

and the restriction $G_s \boldsymbol m'$35 has full row rank on each helper block $G_s \boldsymbol m'$36. The per-helper transfer matrix

$G_s \boldsymbol m'$37

has rank $G_s \boldsymbol m'$38, allowing each helper to realize any desired $G_s \boldsymbol m'$39-symbol contribution to the global syndrome. The stale node’s measurement returns

$G_s \boldsymbol m'$40

so the updated coded symbols are recovered exactly (Dubey, 19 May 2026).

The converse uses the superdense coding bound. If helper $G_s \boldsymbol m'$41 sends a quantum system of dimension $G_s \boldsymbol m'$42, then because the stale node finally possesses all transmitted systems, including the entangled partners carried by the other helpers, that channel can support at most $G_s \boldsymbol m'$43 distinguishable signals. Fixing all helpers except one leaves an $G_s \boldsymbol m'$44-dimensional affine subspace of candidate updated messages, and the MDS property implies that the stale node must distinguish $G_s \boldsymbol m'$45 possible stale updated values from the remaining helper’s transmission. Therefore

$G_s \boldsymbol m'$46

For integer-qudit protocols this gives

$G_s \boldsymbol m'$47

per helper, matching the CSS construction exactly (Dubey, 19 May 2026).

5. Obliviousness and adaptivity in dynamic graph algorithms

In dynamic graph algorithms, the central question is different: how much easier a problem becomes when the update sequence is fixed in advance rather than chosen adaptively from the algorithm’s previous outputs. The 2025 paper establishes the first update-time separations of this kind for natural dynamic graph problems with explicit input, rather than for contrived oracle problems or separations based on cryptography (Bernstein et al., 23 Oct 2025).

The paper studies incremental algorithms, which allow only edge insertions, and decremental algorithms, which allow only edge deletions. An algorithm that succeeds even when updates are chosen based on past behavior is called robust; one guaranteed only when the update sequence is independent of the algorithm’s randomness and outputs is non-robust. The motivation is that many randomized dynamic graph algorithms maintain witnesses or symmetry-breaking structures whose stability depends on future updates not reacting to the algorithm’s current random state. An adaptive adversary can often destroy the currently maintained witness and force repeated repair, whereas an oblivious adversary cannot target those random choices (Bernstein et al., 23 Oct 2025).

The first main separation concerns incremental maximal independent set. Assuming the Boolean-Matrix-Multiplication hypothesis, every algorithm against an adaptive adversary for maintaining an MIS on an incremental graph with $G_s \boldsymbol m'$48 vertices requires

$G_s \boldsymbol m'$49

total update time, equivalently

$G_s \boldsymbol m'$50

amortized update time. Under the combinatorial BMM hypothesis, every combinatorial algorithm requires

$G_s \boldsymbol m'$51

amortized update time. By contrast, existing fully dynamic non-robust MIS algorithms due to Behnezhad, Derakhshan, Hajiaghayi, Stein, and Sudan, and to Chechik and Zhang, achieve

$G_s \boldsymbol m'$52

update time against oblivious adversaries. The separation is therefore exponential (Bernstein et al., 23 Oct 2025).

The second main separation concerns decremental maximal clique. Assuming the 3SUM or APSP hypotheses, every algorithm against an adaptive adversary for maintaining a maximal clique in each connected component of a decremental graph with $G_s \boldsymbol m'$53 vertices and initial maximum degree $G_s \boldsymbol m'$54 requires

$G_s \boldsymbol m'$55

total update time, equivalently

$G_s \boldsymbol m'$56

amortized update time. On the non-robust side, the paper proves that there is an algorithm against an oblivious adversary that, with high probability, maintains a maximal clique in every connected component in

$G_s \boldsymbol m'$57

amortized update time. The adaptive lower bound is tight up to subpolynomial factors because there is a robust decremental maximal clique algorithm with $G_s \boldsymbol m'$58 amortized update time (Bernstein et al., 23 Oct 2025).

A byproduct is a separation between incremental and decremental algorithms for triangle detection. Assuming OMv, every incremental algorithm that reports YES once a triangle exists requires

$G_s \boldsymbol m'$59

total update time. In contrast, there is a randomized decremental algorithm against an adaptive adversary that, with high probability, maintains a triangle and reports NO once no triangle exists anymore in

$G_s \boldsymbol m'$60

total update time. Because triangle detection is a decision problem with uniquely determined outputs, the incremental lower bound applies even against an oblivious adversary. The paper identifies this as, to its knowledge, the first separation of this kind (Bernstein et al., 23 Oct 2025).

6. Proof mechanisms, qualifications, and research directions

The graph-theoretic separations rely on reductions that explicitly exploit adaptivity. For decremental maximal clique, the starting point is All-Edges Triangle Detection on a tripartite graph $G_s \boldsymbol m'$61. A decremental algorithm for maintaining a maximal clique in each connected component can be run directly on the tripartite graph, where every clique has size at most $G_s \boldsymbol m'$62. In a non-singleton component, if the maintained maximal clique has size $G_s \boldsymbol m'$63, it is a triangle $G_s \boldsymbol m'$64, so the reduction outputs YES for $G_s \boldsymbol m'$65 and deletes $G_s \boldsymbol m'$66; if the maintained maximal clique has size $G_s \boldsymbol m'$67, that edge cannot lie in any triangle by maximality, so it is deleted. The next deletion therefore depends on the algorithm’s current clique output, which is exactly why the lower bound targets adaptive adversaries (Bernstein et al., 23 Oct 2025).

The MIS lower bound proceeds through complement graphs. Since a maximal independent set in $G_s \boldsymbol m'$68 is a maximal clique in $G_s \boldsymbol m'$69, one might hope for a direct complement reduction, but a naive version fails because a universal vertex in the original graph can force the MIS output to a singleton. The paper resolves this by constructing two copies of the complement graph and adding cross edges among marked vertices so that the maintained MIS remains informative. The update sequence again depends on the algorithm’s current output, and the reduction yields an $G_s \boldsymbol m'$70-time triangle detector from an incremental MIS data structure with total update time $G_s \boldsymbol m'$71 (Bernstein et al., 23 Oct 2025).

The storage literature has a different set of qualifications. The 2014 classical results analyze only the one-symbol-update regime

$G_s \boldsymbol m'$72

Multiple sparse updates are explicitly left as future work. The converses assume linear encoding, although update protocols may be nonlinear; the update requirement is exact; some constructions rely on sufficiently large field size and existence arguments via Schwartz-Zippel; and the optimal schemes assume access to any two updated nodes in the general linear-code setting or any $G_s \boldsymbol m'$73 updated nodes in the MDS setting. The paper also identifies practical issues such as explicit code design and the minimal auxiliary state needed to realize update algorithms (Nakkiran et al., 2014).

The quantum extension imposes its own assumptions. The storage code is an exact $G_s \boldsymbol m'$74 MDS code over $G_s \boldsymbol m'$75; the field is assumed prime with

$G_s \boldsymbol m'$76

the stale node contacts exactly $G_s \boldsymbol m'$77 helpers; the helpers share prior entanglement among themselves; and achievability is stated for integer-dimension qudits. The paper explicitly highlights open directions, including removing the ceiling gap for odd $G_s \boldsymbol m'$78 under more general quantum channels, understanding entanglement-bandwidth tradeoffs with limited or noisy entanglement, allowing $G_s \boldsymbol m'$79 helpers, and extending beyond MDS codes (Dubey, 19 May 2026).

Across these formulations, the common technical issue is not the same algorithmic task but the same informational asymmetry. In distributed storage, the asymmetry is absence of update metadata, so the problem is communication-theoretic. In dynamic graph algorithms, the asymmetry is whether future updates can react to the algorithm’s revealed state, so the problem is adversarial and update-time-theoretic. The recent results show that this asymmetry can determine exact capacity in storage and create exponential complexity gaps in dynamic graphs (Nakkiran et al., 2014, Bernstein et al., 23 Oct 2025, Dubey, 19 May 2026).