Near-optimal Repair of Reed-Solomon Codes with Low Sub-packetization

TL;DR

This paper introduces a new class of Reed-Solomon codes called $psilon$-MSR codes that achieve near-optimal repair bandwidth with polynomial sub-packetization, improving practicality over previous exponential solutions.

Contribution

It constructs constant-rate $psilon$-MSR Reed-Solomon codes with polynomial sub-packetization, balancing repair bandwidth and sub-packetization size.

Findings

Polynomial sub-packetization achieved for $psilon$-MSR codes.

Explicit tradeoff between repair bandwidth and sub-packetization.

Improved practicality over exponential sub-packetization codes.

Abstract

Minimum storage regenerating (MSR) codes are MDS codes which allow for recovery of any single erased symbol with optimal repair bandwidth, based on the smallest possible fraction of the contents downloaded from each of the other symbols. Recently, certain Reed-Solomon codes were constructed which are MSR. However, the sub-packetization of these codes is exponentially large, growing like $n^{\Omega(n)}$ in the constant-rate regime. In this work, we study the relaxed notion of $\epsilon$-MSR codes, which incur a factor of $(1+\epsilon)$ higher than the optimal repair bandwidth, in the context of Reed-Solomon codes. We give constructions of constant-rate $\epsilon$-MSR Reed-Solomon codes with polynomial sub-packetization of $n^{O(1/\epsilon)}$ and thereby giving an explicit tradeoff between the repair bandwidth and sub-packetization.

Equations

$$\underset{i\in [n]}{\max }N(\mathcal{C},i,[n]\backslash \{i\})$$

$$N(\mathcal{C},i,\mathcal{R})\ge \frac{(n-1)l}{n-k},$$

$${\dim }_{{\mathbb{F}}_q}(\{x_i:x\in {\mathcal{P}}_i\})=l,$$

$$b\ge \sum _{j\in [n]\backslash \{i\}}{\dim }_{{\mathbb{F}}_q}(\{x_j:x\in {\mathcal{P}}_i\})$$

$${\mathrm{tr}}_{F/{\mathbb{F}}_q}(x):=x+x^q+x^{q^2}+\cdots +x^{q^{t-1}}.$$

$$h(x)=\prod _{j\in [n]\backslash (R_{i^{\ast }}\cup \{i^{\ast }\})}(x-{\beta }_j)$$

$$v_{i^{\ast }}{\beta }_{i^{\ast }}^{s}h({\beta }_{i^{\ast }})c_{i^{\ast }}=-\sum _{j\ne i^{\ast }}{v}_{j}h({\beta }_j){\beta }_j^s{c}_j$$

$${\mathrm{tr}}_{i^{\ast }}(v_{i^{\ast }}{\beta }_{i^{\ast }}^{s}h({\beta }_{i^{\ast }})c_{i^{\ast }})$$

$$=-\sum _{j\ne i^{\ast }}{\beta }_j^s{\mathrm{tr}}_i(v_{j}h({\beta }_j)c_j)$$

$$\frac{p_i+k-1}{p_i}\cdot l\le (2+\delta )(1-c/2)\cdot \frac{n-1}{r}\cdot l,$$

$$\prod _{i\in [m]}{p}_i\le (r/2{)}^{\lceil \frac{2+\delta }{c}\rceil }.\text{qed}$$

$${\left(r\cdot (1-c_1ϵ)\right)}^{\lceil \frac{1}{c{c}_1ϵ}\rceil }$$

$$c_1:=\frac{1}{\delta +\max \{ϵ+1-c,2ϵ\}}$$

$$p_i+k-1\le n-\lceil c_1ϵr\rceil$$

$$\frac{p_i+k-1}{p_i}\cdot l$$

$$\le (1+ϵ)\cdot \frac{n-1}{r}\cdot l,$$

$$\prod _{i\in [m]}{p}_i\le {\left(r\cdot (1-c_1ϵ)\right)}^{\lceil \frac{1}{c{c}_1ϵ}\rceil }.\text{qed}$$

Full text

I Introduction

In practical distributed storage systems, data is stored in encoded form on a large number of individual storage nodes to protect it from node failure. The original file is encoded using an $[n,k]$ code and is distributed among $n$ different storage units. Each one of the storage units is called a node and contains one symbol of the codeword. Maximum Distance Separable (MDS) codes are widely used in this case because they achieve the highest possible error-correction capability for a given redundancy level — the codeword can be fully recovered by accessing any $k$ of its $n$ entries. Reed-Solomon (RS) codes are among the most commonly used MDS codes, including in storage applications.

In practice, however, the most common scenario is the failure of a single node [9]. To repair a single node failure, the system needs to download information from some other helper nodes of the codeword, and the total amount of downloaded data is called the repair bandwidth. By the MDS property, it is possible to recover the content of the entire file, and therefore that of the failed node, by downloading the entire content stored on any $k$ nodes. (On the other hand, the same MDS property means that one cannot recover any information about the failed node if one contacts fewer than $k$ nodes.) However, this naive approach can be far from optimal and it is shown in [4] that one can save repair bandwidth by contacting $d>k$ helper nodes and downloading only part of the information stored on each of those helper nodes. Codes with this property are called regenerating codes. In fact, one can attain the maximum savings by contacting all other $n-1$ nodes (i.e. $d=n-1$). We shall therefore focus on the case when $d=n-1$ throughout this paper.

Initial constructions of regenerating codes were vector MDS codes, whose symbols are vectors in $\mathbb{F}^{l}$ for some field $\mathbb{F}$, with the codes being $\mathbb{F}$-linear. The quantity $l$ is called the sub-packetization of the code. We focus on linear repair schemes where the helper nodes then return (much fewer than $l$) $\mathbb{F}$-linear combinations of the vector stored at them.

Shanmugam et al. [12] first propose a framework for studying the repair bandwidth of scalar MDS codes. In this framework, each node contains a symbol of some finite symbol field $E$, which is a degree $l$ extension of some base field $\mathbb{F}_{q}$ (i.e. $[E:\mathbb{F}_{q}]=l$). The code itself is a linear MDS code over the bigger field $E$. The symbol field $E$ can thus be viewed as a $l$-dimensional vector space on $\mathbb{F}_{q}$ and the code can also be viewed as a vector code over $\mathbb{F}_{q}$ with sub-packetization $l$. When a helper node is contacted, instead of returning a symbol of the symbol field $E$, it returns sub-symbols of the base filed $\mathbb{F}_{q}$. The repair bandwidth is formally defined as the total amount of sub-symbols of $\mathbb{F}_{q}$ downloaded from all the helper nodes.

Definition I.1** (Repair bandwidth).**

Let $\mathcal{C}$ be an $[n,k]$ MDS code with sub-packetization $l$ over a finite subfield $\mathbb{F}_{q}$. For $i\in\{1,2\cdots,n\}$ and $\mathcal{R}\subseteq[n]\backslash\{i\}$, define $N(\mathcal{C},i,\mathcal{R})$ as the smallest number of sub-symbols of $\mathbb{F}_{q}$ (which can be linear combinations of the sub-symbols stored in the helper nodes) one needs to download from the helper nodes $\{c_{j}:j\in\mathcal{R}\}$ in order to repair the failed node $c_{i}$. The repair bandwidth of the code $\mathcal{C}$ is defined as

[TABLE]

For any MDS code, Dimakis et al. [4] provides a benchmark for the repair bandwidth by giving an achievable lower bound, known as the cut-set bound. Codes that achieve this lower bound are known as Minimum Storage Regenerating (MSR) codes.

Definition I.2** (Cut-set bound and MSR codes).**

Let $\mathcal{C}$ be an $[n,k]$ (scalar or vector) MDS code with sub-packetization $l$ over some base field $\mathbb{F}_{q}$. For any $i\in[n]$ and any subset $\mathcal{R}\subseteq[n]\backslash\{i\}$, we have the following inequality:

[TABLE]

with equality attained if and only if each node in $[n]\backslash\{i\}$ returns $\frac{l}{n-k}$ symbols of $\mathbb{F}_{q}$. A code achieving this lower bound is called a minimum storage regenerating (MSR) code.

By now several constructions of MSR codes are known. However, the sub-packetization of these constructions is large. In particular, the constructions in [14, 11] are explicit with small field size, and achieve sub-packetization $l\approx r^{n/r}$. Such a large sub-packetization has been shown to be inherent to MSR codes, with a lower bound of $\exp(\Omega(\sqrt{n/r}))$ [5] which was recently improved to a near-optimal $\exp(\Omega(n/r))$ lower bound [1].

While essentially optimal MSR codes have now been constructed, these are tailormade constructions of vector MDS codes. It is of significant theoretical and practical interest to study whether (scalar) MDS codes like Reed-Solomon codes, which are already widely used in practice, can allow for efficient regeneration of a failed node. There have been several recent works in this direction. Guruswami and Wootters [7] give an exact characterization for linear repair schemes of scalar MDS codes using dual codes. They show that to obtain a low repair bandwidth, it suffices to find a set of dual codewords that span the entire field $E$ on the failed node, but have low dimension on other nodes.

Definition I.3** (Dual Code).**

The dual code of a linear code $\mathcal{C}\subseteq E^{n}$ is the linear subspace of $E^{n}$ defined by $\mathcal{C}^{\bot}=\{x=(x_{1},\cdots,x_{n})\in E^{n}\mid\sum_{i=1}^{n}x_{i}c_{i}=0\ \forall c=(c_{1},\cdots,c_{n})\in\mathcal{C}\}$.

Theorem I.4** ( [7]).**

*Let $C\subseteq E^{n}$ be a scalar linear MDS code of length $n$. Let $\mathbb{F}_{q}$ be a subfield of $E$ such that $[E:\mathbb{F}_{q}]=l$. For a given $i\in\{1,\cdots,n\}$, the following statements are equivalent.

(1) There is a linear repair scheme of node $c_{i}$ over $\mathbb{F}_{q}$ such that the repair bandwidth $N(\mathcal{C},i,[n]\backslash\{i\})\leq b$.

(2) There is a subset of codewords $\mathcal{P}_{i}\subseteq\mathcal{C}^{\bot}$ with size $|\mathcal{P}_{i}|=l$ such that*

[TABLE]

and

[TABLE]

Using their characterization, the authors of [7] constructs a family of RS codes with low sub-packetization $l=\log_{n/r}n$ and a repair scheme with optimal repair bandwidth in this regime. However, the repair bandwidth is much higher than the cut-set bound, which can only be achieved for large sub-packetization. Subsequent work [3, 2] generalize the results in [7] but none of their results approaches the cut-set bound.

In a beautiful work, Tamo, Ye, and Barg [13] constructed Reed-Solomon codes that are MSR, i.e., admit repair schemes with repair bandwidth meeting the cut-set bound. The sub-packetization is huge, $l=n^{O(n)}$, but they also prove a lower bound of $k^{\Omega(k)}$ for scalar MDS codes, which is even higher than the exponential lower bound for general MSR (vector MDS) codes.

Given the large sub-packetization of MSR codes which is not suitable for practical applications, Guruswami and Rawat [6] proposed and studied codes that trade-off repair bandwidth with sub-packetization, They constructed codes with sub-packetization $l$ as small as $r=n-k$ with repair bandwdith at most twice the cut-set bound, and $l\approx r^{1/\epsilon}$ with repair bandwidth at most $(1+\epsilon)$ times the cut-set bound, i.e., bounded by $(1+\epsilon)(n-1)l/r$. In a later work, Rawat et al [10] propose $\epsilon$-MSR codes where the download from each helper node is at most $(1+\epsilon)l/r$ (so there is also load balancing across nodes). They also construct $\epsilon$-MSR codes with sub-packetization of $r^{O(r/\epsilon)}\log n$ by combining short MSR codes with long codes of large relative minimum distance.

Definition I.5** ($\epsilon$-MSR code).**

Let $\mathcal{C}$ be an $[n,k]$ (scalar or vector) MDS code with sub-packetization $l$ over some base field $\mathbb{F}_{q}$. It is said to be $\epsilon$-MSR if for every $i\in[n]$, we have $N(\mathcal{C},i,[n]\setminus\{i\})\leq(1+\epsilon)\cdot\frac{(n-1)l}{n-k}$, with each node returning at most $(1+\epsilon)\cdot\frac{l}{n-k}$ symbols of $\mathbb{F}_{q}$ during the repair process.

Given the recent developments on MSR Reed-Solomon codes (with large sub-packetization) and $\epsilon$-MSR codes (with low sub-packetization), a natural question that arises is whether we can combine the benefits of both these lines of work, and obtain $\epsilon$-MSR Reed-Solomon codes with low sub-packetization. This is precisely the question addressed in this work. In this paper, we provide a partial answer to this question by constructing two families of RS codes that achieve small repair bandwidth using polynomial sub-packetization in the constant rate regime of $k=\Theta(n)$. (Our constructions also work beyond this regime, but we will be focusing on the tradeoff in the constant rate regime for simplicity.)

The constructions in this paper rely on the technique of picking multiple prime numbers introduced in [13].

• •

Our first construction (Section II-B) gives a family of $[n,k]$ $O(1)$-MSR RS codes with sub-packetization $O(n-k)^{O(1)}$.

• •

A more careful choice of parameters leads to our second construction (II-C) of a family of $[n,k]$ $\epsilon$-MSR RS codes with sub-packetization $O(n-k)^{O(1/\epsilon)}$.

Moreover, we conjecture that this tradeoff is essentially tight.

Conjecture I.6** (Tradeoff between repair bandwidth and sub-packetization).**

Any $[n,k]$ $\epsilon$-MSR RS code has sub-packetization $(n-k)^{\Omega(1/\epsilon)}$ and this is tight up to a constant factor in the exponent.

Remark I.7**.**

In our constructions, the number of helper nodes from which one needs to download information to repair the failed node might be smaller than $n-1$. Nevertheless, we are comparing our repair bandwidth with the cut-set bound in Definition I.2 where the number of helper nodes is $n-1$, which is the smallest possible.

Related independent work on near-MSR RS codes. We notice that the question of understanding the tradeoff between repair bandwidth and sub-packetization for RS codes is also studied in a recent independent work [8]. Li et al. [8] give four different constructions of RS codes using three different schemes. Their constructions, however, work in very different regimes and do not admit as clean and explicit tradeoff as our results. To get an idea of how their results compare with ours, we assume $k=r=n/2$ which is a representative case of the constant rate regime of $k=\Theta(n)$. Their first construction achieves repair bandwidth of $\frac{l}{a}(n-1)(a-s)$ when $n<q^{a},r=n-k>q^{s}$ and $a|l$. This construction saves a factor of about $\frac{a-s}{2a}\geq\Omega\left(\frac{1}{\log_{q}n}\right)$ from the naive repair scheme but is still far away from the cut-set bound, which is only $O(1/n)$ times the bandwidth of the naive repair scheme. This construction, however, works for logarithmically small sub-packetization $l=O(\log_{q}n)$ while our construction is for polynomially large $l$. Their second construction saves almost half of the repair bandwidth compared to the naive scheme when $l\approx r\log_{q}n$. This is again for small sub-packetization. Their third construction attains the repair bandwidth of $\frac{l}{r}(n+1+r(q^{a}-2))$ when $n\leq(q^{a}-1)\log_{r}\frac{l}{a}$ and $a|l$. In order for this to be within a constant factor from the cut-set bound, one needs to have $q^{a}-2=O(1)$ which implies an exponentially large sub-packetization $\frac{l}{a}\geq r^{\Omega(n)}=\Omega(n)^{\Omega(n)}$. This is sub-optimal compared to our construction which only needs polynomially large sub-packetization. The last construction in [8] attains the repair bandwidth of $\frac{l}{r}(n-1+(r-1)(q^{a}-2))$ when $n\leq(q^{a}-1)m$ and $l/a\approx m^{m}$. Again if we are targeting at $O(1)$-MSR RS codes, we need to take $q^{a}-2=O(1)$ and this gives $m=\Omega(n)$ and an exponentially large sub-packetization $\frac{l}{a}=\Omega(n)^{\Omega(n)}$, which is far from optimal compared to our results.

II Constructions of Near-MSR Reed-Solomon Codes

II-A Notation

Throughout this paper, for positive integer $i$, we use $[i]$ to denote the set $\{1,\cdots,i\}$. $[n,k]$ is used to denote the length and the dimension of a code. $r:=n-k$ is the number of parity symbols of a code. We use $E$ to denote the finite symbol field of the code, i.e. each coordinate of a codeword is a symbol in $E$. We use $\mathbb{F}_{q}$ to denote the base field and $l$ the sub-packetization of $E$ over $\mathbb{F}_{q}$, i.e. $[E:\mathbb{F}_{q}]=l$. When $F$ is a degree $t$ extension of a base field $\mathbb{F}_{q}$, the trace function $\mathrm{tr}_{F/\mathbb{F}_{q}}:F\rightarrow\mathbb{F}_{q}$ is defined as

[TABLE]

II-B A family of $O(1)$-MSR Reed-Solomon codes with $O(r)^{O(1)}$ Sub-packetization

In this section, we give the construction of a family of Reed-Solomon codes with polynomial sub-packetization whose repair bandwidth is within a small constant times the cut set bound. The construction given below achieves the smallest sub-packetization that can be achieved using our construction.

Theorem II.1**.**

Suppose $r:=n-k=cn$, where $c\in(0,1)$ is an arbitrary constant. There exists a family of $(n,k)$ Reed-Solomon codes for sufficiently large $n$ with sub-packetization at most $(\frac{r}{2})^{\lceil\frac{2+\delta}{c}\rceil}$, for some small constant $\delta>0$, such that any code in this family is $((2+\delta)(1-c/2)-1)$-MSR.

Proof.

We start by picking $m=\lceil\frac{2+\delta}{c}\rceil$ primes $p_{1},\cdots,p_{m}$ in the range $[r/(2+\delta),r/2]$. This can be done for sufficiently large $n$ (and therefore sufficiently large $r$) since the number of primes in $\{1,2,\cdots,N\}$ is roughly $\frac{N}{\log N}$ according to the prime number theorem and $m$ is only a constant. For any $i\in[m]$, let $\alpha_{i}$ be an element with degree $p_{i}$ over the base field $\mathbb{F}_{q}$. Denote $E=\mathbb{F}_{q}(\alpha_{1},\cdots,\alpha_{m})$ and $F_{i}=\mathbb{F}_{q}(\{\alpha_{j},j\neq i\})$. It follows that $E=F_{i}(\alpha_{i})$ and $[E:F_{i}]=p_{i}$. Let $S_{i}$ be the set of conjugates of $\alpha_{i}$, i.e. $S_{i}:=\{\alpha_{i},\alpha_{i}^{q},\cdots,\alpha_{i}^{q^{p_{i}-1}}\}$. Since $|\cup_{i\in[m]}S_{i}|\geq n$, we can pick $n$ elements from $\cup_{i\in[m]}S_{i}$ as the set of evaluation points. Denote the evaluation set by $S=\{\beta_{1},\cdots,\beta_{n}\}$ and the corresponding $(n,k)$ Reed-Solomon code as $\mathcal{C}$.

Now we show how to repair a node corresponding to evaluation point $\beta_{i^{*}}\in S_{i}$ for a codeword $c=(c_{1},\cdots,c_{n})\in\mathcal{C}$. We start by picking $p_{i}+k-1$ evaluation points from $S\backslash S_{i}$ as our repair set $R_{i^{*}}$. This can be done since $|S\backslash S_{i}|\geq n-r/2=r/2+k\geq p_{i}+k-1$. Now consider the polynomial

[TABLE]

which vanishes at each node other than those corresponding to evaluation points in $R_{i^{*}}\cup\{i^{*}\}$. For any $s\leq p_{i}-1$, the polynomial $x^{s}h(x)$ has degree at most $n-k-1$. Notice that the dual code $\mathcal{C}^{\bot}$ is a $(n,n-k)$ generalized Reed-Solomon code with some coefficients $(v_{1},\cdots,v_{n})$ and evaluation points $S$. Thus we have $(v_{1}\beta_{1}^{s}h(\beta_{1}),\cdots,v_{n}\beta_{n}^{s}h(\beta_{n}))\in\mathcal{C}^{\bot}$, i.e.

[TABLE]

Denote the trace $\mathrm{tr}_{E/F_{i}}$ as $\mathrm{tr}_{i}$. We take $\mathrm{tr}_{i}$ on both sides in the equation above

[TABLE]

where in the last equality, we use the fact that $\beta_{j}\notin S_{i}$ and therefore $\beta_{j}\in F_{i}$. Since $v_{i^{*}}h(\beta_{i^{*}})\neq 0$ and $\beta_{i^{*}}\in S_{i}$, $\{v_{i^{*}}\beta_{i^{*}}^{s}h(\beta_{i^{*}})\}_{s=0,\cdots,p_{i}-1}$ forms a basis of $E$ over $F_{i}$. Thus $c_{i^{*}}$ can be reconstructed from $\{\mathrm{tr}_{i}(v_{i^{*}}\beta_{i^{*}}^{s}h(\beta_{i^{*}})c_{i^{*}})\}_{s=0,\cdots,p_{i}-1}$.

For each node $j\neq i^{*}$, we only need to download one symbol $\mathrm{tr}_{i}(v_{j}h(\beta_{j})c_{j})$ from the field $F_{i}$, which is $1/p_{i}$ the number of symbols stored in node $j$. Thus the number of symbols downloaded from each node is at most

[TABLE]

implying that the code is $((2+\delta)(1-c/2)-1)$-MSR. We finish the proof of the theorem by noticing that the sub-packetization is exactly

[TABLE]

II-C A family of $\epsilon$-MSR Reed-Solomon codes with $O(r)^{O(1/\epsilon)}$ Sub-packetization

In this section, we give a tradeoff between sub-packetization and bandwidth when the bandwidth is close to the cut-set bound. Specifically, when the repair bandwidth is within $(1+\epsilon)$ times the cut-set bound, our construction has sub-packetization at most $O(r)^{O(1/\epsilon)}$. More specifically, we have the following theorem.

Theorem II.2**.**

Suppose $r:=n-k=cn$, where $c\in(0,1)$ is some arbitrary constant. For any constant $\epsilon>0$, there exists a family of $[n,k]$ Reed-Solomon codes for sufficiently large $n$ with sub-packetization at most

[TABLE]

where

[TABLE]

for some small positive constant $\delta$, such that any code in this family is $\epsilon$-MSR.

Proof.

Define $c_{2}:=\frac{1}{\max\{\epsilon+1-c,2\epsilon\}}>c_{1}$ to be some slightly larger constant and $m:=\lceil\frac{1}{cc_{1}\epsilon}\rceil$. We start by picking $m$ prime numbers $p_{1},\cdots,p_{m}$ in the range $[r(1-c_{2}\epsilon),r(1-c_{1}\epsilon)]$, which can always be done when $n$ is large enough according to the prime number theorem. Compared with the construction in Theorem II.1, we are picking a factor of $O(1/\epsilon)$ more prime numbers in a narrower range when $\epsilon$ is small. It increases the sub-packetization by a factor of $O(1/\epsilon)$ on the exponent but allows us to pick only $O(\epsilon n)$ evaluation points corresponding to each prime number. In this way, when a node that corresponds to some prime number $p_{i}$ crashes, we can pick more helper nodes that correspond to different primes and thus decrease the repair bandwidth.

For each $i\in[m]$, denote $\alpha_{i}$ an element with degree $p_{i}$ over the base field $\mathbb{F}_{q}$ and let $S_{i}:=\{\alpha_{i},\alpha_{i}^{q},\cdots,\alpha_{i}^{q^{p_{i}-1}}\}$. Again denote $E=\mathbb{F}_{q}(\alpha_{1},\cdots,\alpha_{m})$ and $F_{i}=\mathbb{F}_{q}(\{\alpha_{j},j\neq i\})$. For each $i$, we pick a set of $S^{\prime}_{i}\subset S_{i}$ with $\lceil c_{1}\epsilon r\rceil$ elements. This can be done because $|S^{\prime}_{i}|=\lceil c_{1}\epsilon r\rceil\leq r(1-c_{2}\epsilon)\leq p_{i}$. Since $|\cup_{i\in[m]}S^{\prime}_{i}|\geq m\cdot\lceil cc_{1}\epsilon n\rceil\geq n$, we can pick a set of $n$ evaluation points in $\cup_{i\in[m]}S^{\prime}_{i}$. Denote the evaluation set by $S=\{\beta_{1},\cdots,\beta_{n}\}$ and the corresponding $(n,k)$ Reed-Solomon code as $\mathcal{C}$.

The way to repair a single node failure is similar to the one used in the proof of Theorem II.1. When a node corresponding to $\beta_{i^{*}}\in S_{i}$ fails, we will pick a set of $(p_{i}+k-1)$ nodes from $S\backslash S_{i}$ to transmit information to the failed node and apply the same repair scheme as in the proof of theorem II.1. This set of back-up nodes can be chosen since

[TABLE]

where the RHS is exactly the number of nodes not in $S_{i}$. The number of symbols downloaded from each helper node towards repair of a node in $S_{i}$ is thus

[TABLE]

implying that the code is $\epsilon$-MSR. The sub-packetization equals

[TABLE]