---
title: Exact Moved-Load Repair Analysis
url: https://www.emergentmind.com/topics/exact-moved-load-repair
type: topic
---

# Exact Moved-Load Repair Analysis

Searching arXiv for the cited work and closely related exact-repair papers to ground the article.
arXiv_search: query="1807.01166 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 [1807.01166]. 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 [2606.08377]. 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 \(k\) nodes suffice for reconstruction, and \(d\) helpers participate in repair. If the file size is \(\mathcal M\), each node stores \(\alpha\), each helper sends \(\beta\), and the total repair bandwidth is \(\gamma=d\beta\) [1402.2343]. 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 [1402.2343].

In the scheduling formulation, the moved-load metric is explicit. For a feasible schedule \(\sigma\) and any mapping \(\tau:[n]\to[m]\), the disagreement set is
\[
M(\sigma,\tau)=\{j\in[n]: \sigma(j)\neq \tau(j)\},
\]
and the moved-load is
\[
move(\sigma,\tau)=\sum_{j\in M(\sigma,\tau)} p_j.
\]
The corresponding exact repair problem asks whether there exists a feasible schedule \(\sigma\) such that
\[
(\sigma)\le T \quad\text{and}\quad move(\sigma,\hat\sigma)\le K
\]
for a given feasible predicted schedule \(\hat\sigma\), target makespan \(T\), and budget \(K\) [2606.08377].

## 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
\[
\mathcal{M}\le \sum_{i=0}^{k-1}\min\left\{\alpha,(d-i)\frac{\gamma}{d}\right\},
\]
with the MSR point
\[
\alpha=\frac{\mathcal M}{k}, \qquad \gamma=\frac{d\mathcal M}{k(d-k+1)},
\]
and the MBR point
\[
\alpha=\frac{2d\mathcal M}{k(2d-k+1)}, \qquad \gamma=\frac{2d\mathcal M}{k(2d-k+1)}
\]
[1402.2343]. Exact repair is stricter, so functional-repair bounds remain outer bounds for it [1402.2343].

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/n\le 1/2\) and for \(k\le 3\), while repairing both systematic and parity nodes exactly [1001.0107]. More generally, exact regeneration is asymptotically as efficient as functional regeneration for every \((n,k)\), in the sense that
\[
\lim_{M\to\infty}\frac{B}{M}=\frac{n-1}{k(n-k)}
\]
for exact MSR repair bandwidth \(B\) and file size \(M\) [1004.4299].

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 \(n!\) permutations of the resulting heterogeneous system to obtain a homogeneous code in average [1402.2343]. 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 \(\epsilon\)-MSR codes

The most precise storage-theoretic analogue of exact moved-load repair is the \(\epsilon\)-MSR construction of “contacting fewer code blocks for exact repair” [1807.01166]. The underlying object is an \([n,k\ell,d_{\min}=n-k+1,\ell]_{\mathbb B}\) vector MDS code, where a codeword consists of \(n\) code blocks, each storing \(\ell\) symbols over \(\mathbb B\), or equivalently one symbol over an extension field \(\mathbb F\) of degree \(\ell\) over \(\mathbb B\) [1807.01166]. Exact repair means that when a block \(\mathbf c_i\) fails, the original contents of that failed block are reconstructed exactly.

For an MDS code repaired from \(t\) helpers, the cut-set benchmark is
\[
\left(\frac{t}{t-k+1}\right)\ell
\]
symbols over \(\mathbb B\) in total; under load-balanced repair, each helper sends
\[
\frac{\ell}{t-k+1}
\]
symbols [1807.01166]. Codes attaining this exactly are MSR codes. The \(\epsilon\)-MSR notion allows a multiplicative \((1+\epsilon)\) increase in bandwidth while dramatically reducing sub-packetization. In the \(t=n-1\) form quoted in the paper, an \(\epsilon\)-MSR code has repair bandwidth at most
\[
(1+\epsilon)\cdot \frac{\ell}{n-k}.
\]

The key contribution is a reduced-contact exact-repair property. For \(k\le \mathcal T<n-1\) and \(s=\mathcal T-k+1\), an \(\epsilon\)-MSR code
\[
\mathcal C=[n,k\ell,d_{\min}=n-k+1,\ell=s^n]
\]
has the \((\mathcal T,\mathcal T')\)-repair property if any failed node can be exactly repaired by downloading at most
\[
(1+\epsilon)\cdot \frac{\ell}{s}
\]
symbols from each contacted helper, where \(\mathcal T'\) helpers are compulsory and the remaining \(\mathcal T-\mathcal T'\) may be chosen arbitrarily [1807.01166]. This is only partially helper-universal: unlike a true \(t\)-optimal MSR code, not every subset of size \(\mathcal T\) is admissible.

The construction is a concatenation \(\mathcal C=\mathcal C^{II}\circ \mathcal C^I\). The inner code \(\mathcal C^I\) is Ye–Barg’s \(t\)-optimal-repair MSR code with parameters
\[
(n,r=n-k,t,\ell=s^n)_{\mathbb B},\qquad s=t-k+1,
\]
and parity-check blocks
\[
H_{j,i}=H_i^{j-1},\qquad H_i=\sum_{b=0}^{\ell-1}\lambda_{i,b_i}\, e_b e_b^T.
\]
It repairs any node by contacting any \(t\) helpers and downloading \(\ell/s\) symbols from each, for total bandwidth \(t\ell/s\) [1807.01166]. The outer code \(\mathcal C^{II}\) is a linear code
\[
(N,K,M,D=\delta N)_q,\qquad M=q^K,\quad q\le n,
\]
with constant relative distance and many codewords of full Hamming weight [1807.01166].

The final code has length \(M\), node size \(N\ell\), and parity-check thick columns indexed by outer-code codewords \(\mathbf a_i=(a_{i,1},\dots,a_{i,N})\). Repair is coordinatewise because the parity-check blocks are diagonal across the \(N\) outer coordinates. For one failed block \(c^1\), fixing one coordinate and partitioning helpers as
\[
Q=\{i\in[2,M]: a_{i,1}=a_{1,1}\},\qquad
V=\{i\in[2,M]: a_{i,1}\neq a_{1,1}\},
\]
one has
\[
|Q|=\frac{M}{q}-1,\qquad |V|=M-\frac{M}{q}.
\]
The helpers in \(Q\) are compulsory. Helpers in \(Q\) send all \(s\) relevant symbols for each local repair group, whereas helpers in \(V\) send only one combined symbol per group,
\[
\mu_{v_i,1,1}^{(b)}:=\sum_{k=0}^{s-1} c^{v_i}_{1,b(a_{1,1},k)}.
\]
A polynomial-interpolation argument based on
\[
p_0(x)=\prod_{u=0}^{s-1}(x-\sigma_1\lambda_{a_{1,1},u}),\qquad p_i(x)=x^i p_0(x)
\]
shows that one local group of \(s\) failed symbols can be recovered by downloading
\[
|Q|s+(|V|-(r-s))
\]
symbols, and repairing the full failed block downloads
\[
\left(\frac{M}{q}-1\right)N\ell + \left(M-n+t-\left(\frac{M}{q}-1\right)\right)\frac{N\ell}{s}
\]
[1807.01166].

The moved-load aspect appears explicitly in the helper-by-helper rewrite. If \(P\) is the contacted helper set, the total download is
\[
\sum_{i\in P} \Big( |\{j\in[1,N]: a_{i,j}=a_{1,j}\}|\ell + |\{j\in[1,N]: a_{i,j}\neq a_{1,j}\}|\frac{\ell}{s} \Big).
\]
Thus each helper has “heavy” coordinates, contributing \(\ell\), and “light” coordinates, contributing \(\ell/s\). The paper proves that the download from each contacted helper is bounded by
\[
(1+\epsilon)\frac{N\ell}{s}
\]
provided
\[
\delta \ge 1-\frac{\epsilon}{r-1},
\]
and summarizes the result by saying that the codes “ensure load balancing among the contacted code blocks” [1807.01166].

The asymptotic theorem is the strongest practical statement. For fixed positive integers \(r\), \(s\le r\), \(u>3\), and \(\epsilon>0\), there exists a constant square prime power \(q\) such that for infinitely many \(\mathcal N\), there is an
\[
(\mathcal N,\mathcal K=\mathcal N-r,\mathcal T=\mathcal N-s,\mathcal L)_{\mathbb B}
\]
\(\epsilon\)-MSR code satisfying
\[
(\mathcal T=\mathcal N-s,\ \mathcal T' \le \mathcal N-\mathcal N^{\frac{u-1}{u}})
\]
repair, with
\[
\mathcal L = O_{s,q,u}(\log \mathcal N), \qquad |\mathbb B| = O_{r,q}(\mathcal N)
\]
[1807.01166]. Repair applies to any failed code block, and the code is MDS. The caveat is explicit: obtaining exact repair from any arbitrary subset of \(\mathcal T\) helpers remains future work [1807.01166].

## 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
\[
\mathcal G=(\mathcal N,\mathcal A),
\]
where \(z_{ij}\) is the number of packets transmitted from node \(i\) to node \(j\) during repair, and the repair-cost is
\[
\sigma_c=\sum_{(ij)\in\mathcal A} z_{ij}
\]
[1401.2774]. This is a topology-aware moved-load metric: a packet that traverses multiple hops contributes once per hop.

The lower bound minimizes \(\sigma_c\) subject to cut constraints requiring that every cut connecting a data collector attached to the newcomer and any \(k-1\) surviving nodes carry at least \(M\), the file size [1401.2774]. The paper proves that this lower bound is achievable for exact repair in tandem networks and for a \((6,3,6)\) \(2\times 3\) grid example. In a tandem network, the exact-optimal result is
\[
\sigma_c \ge M,
\]
and the minimum is achieved by the \(k\) nearest surviving nodes, each transmitting \(M/k\) fragments to its neighbor [1401.2774].

The exact code constructions are Vandermonde-based. In the tandem case, with
\[
\mathbf m=[m_1\ m_2\ \cdots\ m_k]^T,
\]
node \(i\) stores
\[
v_i = m_1 + m_2\alpha_i + \cdots + m_k \alpha_i^{k-1},
\]
and exact repair of failed node \(t\) is achieved by choosing coefficients \(\underline\xi\) such that
\[
w_{t-1}+w_{t+1}=v_t.
\]
Because the associated Vandermonde system is invertible, the exact failed-node content is reproduced [1401.2774]. In the \(2\times 3\) grid, the lower bound for systematic-node repair is \(5\) units, attained by explicit repair subgraphs such as
\[
(0,1,0,1,0,2,1)
\]
for node \(4\) or node \(6\) [1401.2774]. 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 \(\sigma:[n]\to[m]\) with \(\sigma(j)\in\Gamma(j)\) for every job \(j\), machine loads
\[
L_i(\sigma)=\sum_{j:\sigma(j)=i} p_j,
\]
and makespan
\[
(\sigma)=\max_{i\in[m]}L_i(\sigma)
\]
[2606.08377]. The predicted assignment \(\hat\pi\) may be infeasible. The paper projects it to a feasible schedule \(\hat\sigma=Project(\hat\pi)\), and projection is monotone in the sense that
\[
move(\sigma,\hat\sigma)\le move(\sigma,\hat\pi)
\]
for every feasible \(\sigma\) [2606.08377].

The decision version is:
\[
(\sigma)\le T \quad\text{and}\quad move(\sigma,\hat\sigma)\le K.
\]
The prediction error with respect to \(T\) is
\[
E(T)=\min\{move(\sigma,\hat\pi): \sigma \text{ feasible and } (\sigma)\le T\},
\]
and with respect to the optimum it is
\[
E=E(OPT)=\min\{move(\sigma^*,\hat\pi): \sigma^* \text{ feasible and } (\sigma^*)=OPT\}
\]
[2606.08377].

The repair algorithm exploits the overload lower bound
\[
\Delta(T)=\sum_{i\in[m]}(\hat L_i-T)^+,
\qquad
E(T)\ge \lceil \Delta(T)\rceil.
\]
It also uses the incident-set structure
\[
A_{\mathrm{inc}(\sigma,\hat\sigma)}=
\{\hat\sigma(j): j\in M(\sigma,\hat\sigma)\}\cup \{\sigma(j): j\in M(\sigma,\hat\sigma)\},
\]
with
\[
|A_{\mathrm{inc}(\sigma,\hat\sigma)}|\le 2K
\]
whenever \(move(\sigma,\hat\sigma)\le K\) [2606.08377]. This yields a bounded-budget repair oracle: for a guessed machine set \(A\) containing all overloaded machines, a dynamic program over net load changes
\[
b_r=L_{i_r}(\sigma)-\hat L_{i_r},\qquad \sum_{r=1}^a b_r=0,\qquad |b_r|\le K
\]
decides repair feasibility in time
\[
O\!\left(|J_A|\cdot a \cdot (2K+1)^{a-1}\right)
\]
[2606.08377].

Enumerating all candidate \(A\subseteq[m]\) with \(O(T)\subseteq A\) and \(|A|\le 2K\) gives the global repair oracle with runtime
\[
O\!\left(n\cdot m^{2K}\cdot (2K+1)^{2K+1}\right).
\]
Using doubling on \(K\), the main repair theorem states that for any \(T\ge OPT\), the algorithm \(GlobalRepair(T,\hat\pi)\) returns a feasible schedule \(\sigma\) with
\[
(\sigma)\le T,
\]
and if \(\Delta(T)>0\), it stops after reaching some
\[
K<2E(T)\le 2E,
\]
with at most
\[
\left\lceil \log_2\!\left(\frac{E(T)}{\lceil \Delta(T)\rceil}\right)\right\rceil + 1
\]
oracle calls [2606.08377]. The overall running time is
\[
\widetilde{O}\!\left( n \cdot m^{O(E)} \cdot E^{O(E)} \right).
\]

The exactness here is threshold exactness: the output schedule meets the target makespan \(T\) exactly, not a \((1+\varepsilon)T\) relaxation. The paper complements this with a parameterized hardness result:
\[
\textit{Exact Moved-Load Repair is W[1]-hard parameterized by }K,
\]
even when \(\hat\sigma\) is feasible and the instance has at most three distinct processing times [2606.08377]. 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
\[
d_i=(i+1)(k-1),\qquad i=1,\dots,\delta,
\]
with subpacketization
\[
\alpha=(k-1)\operatorname{lcm}(1,2,\dots,\delta),
\]
file size \(F=k\alpha\), and per-helper repair traffic
\[
\beta(d_i)=\frac{\alpha}{d_i-k+1}=\frac{z_\delta}{i},
\qquad
\gamma(d_i)=\frac{(i+1)\alpha}{i}
\]
[1708.03402]. This is exact repair with runtime movement of load across different numbers of helpers, although helper contributions remain symmetric once \(d_i\) is chosen.

At the MBR point, bandwidth adaptivity can be combined with Byzantine error resilience. In the BAER model, the exact MBR law becomes
\[
\beta(d)=\frac{\alpha}{d-2b},\qquad \gamma(d)=\frac{\alpha d}{d-2b},
\]
and the exact MBR storage capacity is
\[
F_{\mathrm{MBR}}
=\frac{\alpha}{d_{\min}-2 b}(k-2 b)\left(d_{\min}-b-\frac{k-1}{2}\right)
\]
[1711.02770]. This shifts moved load not only across helper count, but across honest-versus-adversarial effective dimension \(d-2b\).

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 \(\ell_2\) systematic nodes, then
\[
M^{s} \le (k-\ell_1-\ell_2)\left(1-\frac{1}{d-k+1}\right)^{\ell_2}\alpha,
\]
and for \(d=n-1\),
\[
C_s(\alpha) = (k-\ell_1-\ell_2)\left(1-\frac{1}{n-k}\right)^{\ell_2}\alpha
\]
[1304.3156]. 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 \(\alpha=d\beta\) [1310.0054]. 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 \(d\ge 2k-2\), exact repair with quantum communication attains
\[
\left(\alpha=\frac{B}{k},\ d\beta_{\mathsf q}=\frac{B}{k}\right),
\]
which simultaneously minimizes storage and repair bandwidth in that model [2605.12455]. 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 \(\epsilon\)-MSR storage, helper flexibility is partial because some helpers are compulsory [1807.01166]. In topology-aware storage repair, exact optimality is proved only for tandem networks and a specific \(2\times 3\) grid [1401.2774]. In scheduling, exact moved-load repair at target \(T\) is solvable in XP-type time but is W[1]-hard in the moved-load parameter \(K\) [2606.08377]. 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.

Source: https://www.emergentmind.com/topics/exact-moved-load-repair