Exact Moved-Load Repair Analysis

• Exact moved-load repair is defined as restoring a failed component to its exact target state while controlling the data, traffic, or processing volume moved.
• Methodologies include interference alignment in MSR codes and dynamic programming in scheduling to achieve repair optimality under limited helper participation.
• The work highlights trade-offs in repair bandwidth, sub-packetization, and load balancing with extensions to quantum-assisted repair and security considerations.

Searching arXiv for the cited work and closely related exact-repair papers to ground the article. arXiv_search: query="(Guruswami et al., 2018) exact repair epsilon-MSR codes contacting fewer code blocks", max_results=5 “Exact moved-load repair” denotes a family of exact-recovery problems in which a failed or predicted state is corrected to a prescribed target state while controlling the amount of state, traffic, or processing volume that must be moved. In distributed storage, the closest established notion is exact repair of a failed node or code block together with explicit control of helper participation and repair traffic; the $\epsilon$-MSR construction of “contacting fewer code blocks for exact repair” is the clearest instance of this interpretation (Guruswami et al., 2018). In learning-augmented scheduling, the phrase is formalized directly: given a predicted assignment, a makespan threshold $T$, and a moved-load budget $K$, one asks whether there exists a feasible schedule of makespan at most $T$ within that budget (Xefteris, 7 Jun 2026). Across these uses, the shared invariant is exactness: the repaired object is not merely functionally acceptable, but matches the required target state.

1. Scope and formal meanings

The literature uses the same phrase for structurally similar, but domain-specific, problems. In distributed storage, “moved load” is the traffic required to reconstruct the exact contents of a failed storage unit, either as helper download volume or as total communication moved across a network. In Restricted Assignment scheduling, “moved-load” is the total processing volume of jobs whose machine assignment changes.

Setting	Object being repaired	Moved-load quantity
Distributed storage	Failed node or code block	Repair bandwidth, helper traffic, or $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$
Restricted Assignment scheduling	Predicted assignment $\hat\pi$ or projected schedule $\hat\sigma$	$$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$

In the standard distributed-storage model, a system is parameterized by $(n,k,d)$: $n$ storage nodes, any $T$0 nodes suffice for reconstruction, and $T$1 helpers participate in repair. If the file size is $T$2, each node stores $T$3, each helper sends $T$4, and the total repair bandwidth is $T$5 (Goparaju et al., 2014). Exact repair means that the replacement node stores an exact copy of the failed node’s data, whereas functional repair requires only preservation of the global reconstruction property (Goparaju et al., 2014).

In the scheduling formulation, the moved-load metric is explicit. For a feasible schedule $T$6 and any mapping $T$7, the disagreement set is

$T$8

and the moved-load is

$T$9

The corresponding exact repair problem asks whether there exists a feasible schedule $K$0 such that

$K$1

for a given feasible predicted schedule $K$2, target makespan $K$3, and budget $K$4 (Xefteris, 7 Jun 2026).

2. Exact repair in distributed storage

The modern exact-repair literature is organized around the storage–repair-bandwidth tradeoff. Under functional repair, the cut-set tradeoff is

$K$5

with the MSR point

$K$6

and the MBR point

$K$7

(Goparaju et al., 2014). Exact repair is stricter, so functional-repair bounds remain outer bounds for it (Goparaju et al., 2014).

At the MSR point, exact repair can meet the functional cut-set bound in important regimes. Explicit interference-alignment-based Exact-MSR constructions attain the MSR repair bandwidth with no loss of optimality for $K$8 and for $K$9, while repairing both systematic and parity nodes exactly (1001.0107). More generally, exact regeneration is asymptotically as efficient as functional regeneration for every $T$0, in the sense that

$T$1

for exact MSR repair bandwidth $T$2 and file size $T$3 (Cadambe et al., 2010).

The interior of the exact-repair tradeoff remains more intricate. New inner bounds beyond space-sharing between MSR and MBR can be obtained by starting from a smaller MSR code, appending empty nodes, and then gluing together all $T$4 permutations of the resulting heterogeneous system to obtain a homogeneous code in average (Goparaju et al., 2014). This suggests that “moved-load repair” in storage is not a single point property, but a design axis involving storage cost, helper count, and repair traffic simultaneously.

3. Reduced-contact and load-balanced exact repair via $T$5-MSR codes

The most precise storage-theoretic analogue of exact moved-load repair is the $T$6-MSR construction of “contacting fewer code blocks for exact repair” (Guruswami et al., 2018). The underlying object is an $T$7 vector MDS code, where a codeword consists of $T$8 code blocks, each storing $T$9 symbols over $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$0, or equivalently one symbol over an extension field $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$1 of degree $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$2 over $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$3 (Guruswami et al., 2018). Exact repair means that when a block $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$4 fails, the original contents of that failed block are reconstructed exactly.

For an MDS code repaired from $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$5 helpers, the cut-set benchmark is

$\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$6

symbols over $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$7 in total; under load-balanced repair, each helper sends

$\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$8

symbols (Guruswami et al., 2018). Codes attaining this exactly are MSR codes. The $\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}$9-MSR notion allows a multiplicative $\hat\pi$0 increase in bandwidth while dramatically reducing sub-packetization. In the $\hat\pi$1 form quoted in the paper, an $\hat\pi$2-MSR code has repair bandwidth at most

$\hat\pi$3

The key contribution is a reduced-contact exact-repair property. For $\hat\pi$4 and $\hat\pi$5, an $\hat\pi$6-MSR code

$\hat\pi$7

has the $\hat\pi$8-repair property if any failed node can be exactly repaired by downloading at most

$\hat\pi$9

symbols from each contacted helper, where $\hat\sigma$0 helpers are compulsory and the remaining $\hat\sigma$1 may be chosen arbitrarily (Guruswami et al., 2018). This is only partially helper-universal: unlike a true $\hat\sigma$2-optimal MSR code, not every subset of size $\hat\sigma$3 is admissible.

The construction is a concatenation $\hat\sigma$4. The inner code $\hat\sigma$5 is Ye–Barg’s $\hat\sigma$6-optimal-repair MSR code with parameters

$\hat\sigma$7

and parity-check blocks

$\hat\sigma$8

It repairs any node by contacting any $\hat\sigma$9 helpers and downloading $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$0 symbols from each, for total bandwidth $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$1 (Guruswami et al., 2018). The outer code $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$2 is a linear code

$$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$3

with constant relative distance and many codewords of full Hamming weight (Guruswami et al., 2018).

The final code has length $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$4, node size $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$5, and parity-check thick columns indexed by outer-code codewords $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$6. Repair is coordinatewise because the parity-check blocks are diagonal across the $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$7 outer coordinates. For one failed block $$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$8, fixing one coordinate and partitioning helpers as

$$move(\sigma,\tau)=\sum_{j:\sigma(j)\neq\tau(j)} p_j$$9

one has

$(n,k,d)$0

The helpers in $(n,k,d)$1 are compulsory. Helpers in $(n,k,d)$2 send all $(n,k,d)$3 relevant symbols for each local repair group, whereas helpers in $(n,k,d)$4 send only one combined symbol per group,

$(n,k,d)$5

A polynomial-interpolation argument based on

$(n,k,d)$6

shows that one local group of $(n,k,d)$7 failed symbols can be recovered by downloading

$(n,k,d)$8

symbols, and repairing the full failed block downloads

$(n,k,d)$9

(Guruswami et al., 2018).

The moved-load aspect appears explicitly in the helper-by-helper rewrite. If $n$0 is the contacted helper set, the total download is

$n$1

Thus each helper has “heavy” coordinates, contributing $n$2, and “light” coordinates, contributing $n$3. The paper proves that the download from each contacted helper is bounded by

$n$4

provided

$n$5

and summarizes the result by saying that the codes “ensure load balancing among the contacted code blocks” (Guruswami et al., 2018).

The asymptotic theorem is the strongest practical statement. For fixed positive integers $n$6, $n$7, $n$8, and $n$9, there exists a constant square prime power $T$00 such that for infinitely many $T$01, there is an

$T$02

$T$03-MSR code satisfying

$T$04

repair, with

$T$05

(Guruswami et al., 2018). Repair applies to any failed code block, and the code is MDS. The caveat is explicit: obtaining exact repair from any arbitrary subset of $T$06 helpers remains future work (Guruswami et al., 2018).

4. Network-aware moved communication load

A second storage-centric meaning of moved load appears when the repair cost is not only the traffic entering the newcomer, but the total traffic moved across a multi-hop network. In “Exact Optimized-cost Repair in Multi-hop Distributed Storage Networks,” repair is modeled over a graph

$T$07

where $T$08 is the number of packets transmitted from node $T$09 to node $T$10 during repair, and the repair-cost is

$T$11

(Gerami et al., 2014). This is a topology-aware moved-load metric: a packet that traverses multiple hops contributes once per hop.

The lower bound minimizes $T$12 subject to cut constraints requiring that every cut connecting a data collector attached to the newcomer and any $T$13 surviving nodes carry at least $T$14, the file size (Gerami et al., 2014). The paper proves that this lower bound is achievable for exact repair in tandem networks and for a $T$15 $T$16 grid example. In a tandem network, the exact-optimal result is

$T$17

and the minimum is achieved by the $T$18 nearest surviving nodes, each transmitting $T$19 fragments to its neighbor (Gerami et al., 2014).

The exact code constructions are Vandermonde-based. In the tandem case, with

$T$20

node $T$21 stores

$T$22

and exact repair of failed node $T$23 is achieved by choosing coefficients $T$24 such that

$T$25

Because the associated Vandermonde system is invertible, the exact failed-node content is reproduced (Gerami et al., 2014). In the $T$26 grid, the lower bound for systematic-node repair is $T$27 units, attained by explicit repair subgraphs such as

$T$28

for node $T$29 or node $T$30 (Gerami et al., 2014). This is exact moved-load repair in the literal sense of minimizing total moved communication load under exact data restoration.

5. Exact moved-load repair in learning-augmented scheduling

In Restricted Assignment scheduling, the phrase becomes a formal decision and search problem. A schedule is a mapping $T$31 with $T$32 for every job $T$33, machine loads

$T$34

and makespan

$T$35

(Xefteris, 7 Jun 2026). The predicted assignment $T$36 may be infeasible. The paper projects it to a feasible schedule $T$37, and projection is monotone in the sense that

$T$38

for every feasible $T$39 (Xefteris, 7 Jun 2026).

The decision version is: $T$40 The prediction error with respect to $T$41 is

$T$42

and with respect to the optimum it is

$T$43

(Xefteris, 7 Jun 2026).

The repair algorithm exploits the overload lower bound

$T$44

It also uses the incident-set structure

$T$45

with

$T$46

whenever $T$47 (Xefteris, 7 Jun 2026). This yields a bounded-budget repair oracle: for a guessed machine set $T$48 containing all overloaded machines, a dynamic program over net load changes

$T$49

decides repair feasibility in time

$T$50

(Xefteris, 7 Jun 2026).

Enumerating all candidate $T$51 with $T$52 and $T$53 gives the global repair oracle with runtime

$T$54

Using doubling on $T$55, the main repair theorem states that for any $T$56, the algorithm $T$57 returns a feasible schedule $T$58 with

$T$59

and if $T$60, it stops after reaching some

$T$61

with at most

$T$62

oracle calls (Xefteris, 7 Jun 2026). The overall running time is

$T$63

The exactness here is threshold exactness: the output schedule meets the target makespan $T$64 exactly, not a $T$65 relaxation. The paper complements this with a parameterized hardness result: $T$66 even when $T$67 is feasible and the instance has at most three distinct processing times (Xefteris, 7 Jun 2026). This sharply separates exact repair from merely approximation-sensitive repair.

6. Extensions, tradeoffs, and limitations

Several adjacent literatures broaden the meaning of exact moved-load repair while preserving the same structural tension between exactness and traffic.

Bandwidth-adaptive exact repair at the MSR point is realized by PM-style codes that support multiple helper counts

$T$68

with subpacketization

$T$69

file size $T$70, and per-helper repair traffic

$T$71

(Mahdaviani et al., 2017). This is exact repair with runtime movement of load across different numbers of helpers, although helper contributions remain symmetric once $T$72 is chosen.

At the MBR point, bandwidth adaptivity can be combined with Byzantine error resilience. In the BAER model, the exact MBR law becomes

$T$73

and the exact MBR storage capacity is

$T$74

(Mahdaviani et al., 2017). This shifts moved load not only across helper count, but across honest-versus-adversarial effective dimension $T$75.

Security results show that moved repair data can itself be the source of information leakage. For linear exact-repair MSR codes, if Eve observes repair downloads of $T$76 systematic nodes, then

$T$77

and for $T$78,

$T$79

(Goparaju et al., 2013). Under the stronger Type-II adversary, which observes repair data over time, the only efficient point in the solved secure exact-repair tradeoffs is the MBR point $T$80 (Tandon et al., 2013). This rules out a common misconception: exact moved-load repair is not governed solely by total traffic volume, but also by the subspace geometry of what each helper sends.

A more radical extension appears in entanglement-assisted distributed storage. For $T$81, exact repair with quantum communication attains

$T$82

which simultaneously minimizes storage and repair bandwidth in that model (Hu et al., 12 May 2026). This suggests that the exactness penalty can disappear entirely once the communication model is changed, although the result is specific to entanglement-assisted repair.

The main limitations are therefore domain-specific. In $T$83-MSR storage, helper flexibility is partial because some helpers are compulsory (Guruswami et al., 2018). In topology-aware storage repair, exact optimality is proved only for tandem networks and a specific $T$84 grid (Gerami et al., 2014). In scheduling, exact moved-load repair at target $T$85 is solvable in XP-type time but is W[1]-hard in the moved-load parameter $T$86 (Xefteris, 7 Jun 2026). The term is consequently best understood as a unifying exactness principle rather than a single standardized model: exact restoration under an explicit budget on how much state, traffic, or processing volume may be moved.