{'fraction_non_alphanumeric': 0.05077574047954866, 'fraction_numerical': 0.01106311706629055, 'mean_word_length': 3.8043409211222867, 'pattern_counts': {'":': 0, '<': 7, '<?xml version=': 0, '>': 11, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 18, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Exact-Repair Regenerating Codes Via Layered Erasure Correction and Block Designs

A new class of exact-repair regenerating codes is constructed by combining two layers of erasure correction codes together with combinatorial block designs, e.g., Steiner systems, balanced incomplete block designs and t-designs. The proposed codes have the"uncoded repair"property where the nodes participating in the repair simply transfer part of the stored data directly, without performing any computation. The layered error correction structure makes the decoding process rather straightforward, and in general the complexity is low. We show that this construction is able to achieve performance better than time-sharing between the minimum storage regenerating codes and the minimum repair-bandwidth regenerating codes.


I. INTRODUCTION
Distributed data storage systems can encode and disperse information (a message) to multiple storage nodes (or disks) in the network such that a user can retrieve it by accessing only a subset of them. This kind of systems is able to provide superior reliability performance in the event of disk corruption or network congestion. In order to reduce the amount of storage redundancy required to guarantee such reliability performance, erasure correction codes can be used instead of simple replication of the data.
When the data is coded by an erasure code, data repair (e.g., due to node failure) becomes more involved, because the information stored at a given node may not be directly available from any one the remaining storage nodes, but it can be nevertheless reconstructed since it is a function of the information stored at these nodes. One key issue that affects the system performance is the total amount of information that the remaining nodes need to transmit to the new node. Consider a storage system which has a total of n storage nodes, and the data can be reconstructed by accessing any k of them. A failed node is repaired by requesting any d of the remaining nodes to provide information, and then using the received information to construct a new data storage node. A naive approach is to let these helper nodes transmit sufficient data such that the underlying complete data can be reconstructed, and then the information that needs to be stored at the new node can be subsequently generated. This approach is however rather wasteful, since the data stored at the new node is only a fraction of the complete data.
Dimakis et al. in [1] provided a theoretical framework, namely regenerating codes, to investigate the tradeoff between the amount of storage at each node (i.e., data storage) and the amount of data transfer for repair (i.e., repair bandwidth). It was shown that for the case when the regenerated information at the new node only needs to fulfill the role of the failed node functionally (i.e., functional-repair), but not to replicate exactly the original information content at the failed node (i.e., exact-repair), the problem can be converted to an equivalent network multicast problem, and thus the celebrated network coding result [2] can be applied. By way of this equivalence, the optimal tradeoff between the storage and repair bandwidth was completely characterized in [1] for functional-repair regenerating codes. The two important extreme cases of the optimal tradeoff, where the data storage is minimized and the repair bandwidth is minimized, are referred to minimum storage regenerating (MSR) codes and minimum bandwidth regenerating (MBR) codes, respectively. The problem of functional-repair regenerating codes is well understood and constructions of such codes are available [1], [3], [4].
The functional-repair framework implies that the repair rule and the decoding rule in the system may evolve over time, which incurs additional system overhead. Furthermore, functional repair does not guarantee the data to be stored in systematic form, which is an important practical requirement to consider.
In contrast, exact-repair regenerating codes do not have such disadvantages. The problem of exact-repair regenerating codes was investigated in [5]- [11], all of which address either the MBR case or the MSR case. Particularly, the optimal code constructions in [5] and [7] show that the more stringent exact-repair requirement does not incur any penalty for the MBR case; the constructions in [6]- [8] show that this is also true for the MSR case. These results may lead to the impression that enforcing exact-repair never incurs any penalty compared to functional repair. However, the result in [5] shows that this is not the case, and in fact a large portion of the optimal tradeoffs achievable by functional-repair codes can not be strictly achieved by exact-repair codes 1 .
Codes achieving tradeoff other than the MBR or the MSR points may be more suitable for a system employing exact-repair regenerating codes. From a practical point of view, codes achieving other tradeoff points may have lower complexity than using the time-sharing approach, because the MSR point requires interference alignment, and it is known to be impossible for linear codes to achieve the MSR point for some parameters without symbol extension [6]. As such, it is important to find such codes with competitive performance and low complexity. However, it is in fact unknown whether there even exist codes that can achieve a storage-bandwidth tradeoff better than simply time-sharing between an MBR code and an MSR code. In this work, we provide a linear code construction based on the combination of two layers of erasure correction codes and combinatorial block designs, which is indeed able to achieve tradeoff points better than the time-sharing between an MBR code and an MSR code. The two erasure correction codes are not independent, which must be jointly designed to satisfy certain full rank conditions to guarantee successful decoding. In this work we mainly focus on the case when d = n − 1, i.e., when the repair requires the access to all the other storage nodes, however it can indeed to generalized to the case d < n − 1.
The conceptually straightforward code construction we propose has the property that the nodes participating in the repair do not need to perform any computation, but can simply transmit certain stored information for the new node to synthesis and recover the lost information. The uncoded repair property is appealing in practice, since it reduces and almost completely eliminates the computation burden at the helper nodes. This property also holds in the constructions proposed in [5] and [12]. In fact our construction was partially inspired by and may be viewed as a generalization of these codes. Another closely related work is [18], where repetition and erasure correction codes are combined to construct codes for the MBR point, and one of constructions indeed relies on Steiner systems. The model in [18] is however different from ours (and that in [1]), where the repair procedure only needs to guarantee the existence of one particular d-helper-node combination (fix-access repair), instead of the more stringent requirement that the repair information can come from any d-helper-node combination (random-access repair). Though both models have their merits, we focus on the more stringent and thus more robust random-access repair model in this work.
The rest of the paper is organized as follows. In Section II, a formal definition is given for the coding problem and several relevant existing results are reviewed. Section III provides an example to illustrate the structure of the proposed construction. Section IV provides the general code construction in three progressive steps, and in Section V the performance is analyzed. Finally VI concludes the paper.

II. PROBLEM DEFINITION AND PRELIMINARIES
In this section, we first provide a formal definition of exact-repair regenerating codes. Some existing results on regenerating codes, basics on maximum separable regenerating codes and block designs are also briefly reviewed.

A. Definition of Exact-Repair Regenerating Codes
An (n, k, d) exact-repair regenerating code is a storage system with a total of n storage nodes (disks) 2 , where any k of them can be used to reconstruct the complete data, and furthermore to repair a lost disk, the new disk may access data from any d of the remaining n − 1 disks. Let the total amount of raw data stored be M units and let each storage site stores α units of data, which implies that the redundancy of the system is nα − M . To repair a disk failure (regenerate a new disk), each contributing disk transmits β units of data to the new node, which results in a total of dβ units of data transfer for repair. It is clear that the quantities α and β scale linearly with B, because a code can simply be concatenated. For this reason we shall normalize them the other two quantities using β and use them as the measure of performance from here on.
Formally, the problem can be defined as follows. The notation I n is used to denote the set {1, 2, . . . , n}, and without loss of generality we assume k ≤ d.
which map the message m ∈ I N to n pieces of coded information, which maps the k pieces of coded information in a set A to the original message, which maps a piece of coded information to an index that will be made available to the new node, and which maps d of such indices from the helper nodes to reconstruct the information stored at the lost 2 From here on, we shall use "node" and "disk" interchangably.
node. The functions must satisfy the data reconstruction conditions and the repair conditions Definition 2: A normalized pair (ᾱ,M ) is said to be achievable for (n, k, d) regenerating if for any The quantity ǫ in the definition above is introduced to include the case when the storage-bandwidth tradeoff may be approached asymptotically, e.g., the case discussed in [8].
It is sometimes insightful to consider the case when n is large while k = n − τ 1 and d = n − τ 2 where τ 1 and τ 2 are fixed positive constant integers such that τ 1 ≥ τ 2 . For this purpose, the following two quantities become relevant.
In Section V, we shall show that the proposed codes are able to achieve the entire exponent region E, while time-sharing between the MSR point and the MBR point can not.

B. Cut-Set Outer Bound, MBR Point and MSR Point
As mentioned earlier, the functional-repair regenerating coding problem can be converted to a multicast problem, and through this connection, a precise characterization of the optimal storage-bandwidth tradeoff February 20, 2013 DRAFT was obtained in [1] using cut-set analysis. Since exact-repair is a more stringent requirement than functional-repair, this characterization provides an outer bound for exact-repair regenerating codes.

Theorem 1 ( [1]):
Any exact-repair regenerating codes must satisfy the following condition One extreme case of this outer bound is when the storage is minimized, i.e., the minimum storage regenerating (MSR) point, which is The other extreme case is when the repair bandwidth is minimized, i.e., the minimum bandwidth regen- Both of these two extreme points are achievable [5]- [8] also for the exact-repair case. The functional repair outer bound is however not tight in general, which implies that the exact-repair condition will indeed incur a penalty in many cases [5] [16]. The cut-set outer bound and the two extreme points are illustrated in Fig. 1 for (n, k, d) = (9,7,8); note that the bound is piece-wise linear. The segment between the MSR point and the origin (0, 0) is given by the trivial bound kᾱ ≤M , and it is essentially a degenerate regime because to achieve this segment of tradeoff, we can simply utilize an MSR code but let the helper nodes send more than necessary amount (i.e., more than β units) of data.

C. Maximum Distance Separable Code
A linear code of length-n and dimension k is called an (n, k) code. The Singleton bound (see e.g., [15]) is a well known upper bound on the minimum distance for any (n, k) code.
Theorem 2: The minimum distance d min for an (n, k) code is bounded by d min ≤ n − k + 1.
An (n, k) code that satisfies the Singleton bound with equality is called a maximum distance separable (MDS) code. A key property of an MDS code is that it can correct any (n − k) or less erasures. There are many ways to find MDS codes for any given (n, k) values, n ≥ k. For example, any randomly generated n × k matrix in a sufficiently large alphabet is a generator matrix for an MDS code with high probability. Any n × k Vandermonde matrix can also generate an MDS code when the entries in the second column are all distinct. Another explicit construction approach is by puncturing a Reed-Solomon code of an appropriate alphabet (see e.g., [15]).

D. Block Designs
Block design has been considered in combinatorial mathematics with applications in experimental design, finite geometry, software testing, cryptography, and algebraic geometry. Generally speaking, a block design is a set together with a family of subsets (i.e., blocks) whose members are chosen to satisfy some properties that are deemed useful for a particular application. Usually the blocks are required to all have the same number of elements, and in this case a given block design with parameter (n, k) is specified by (X, B) where X is an n-element set and B is a collection of k-element subsets of X.
One important class of block designs is the t-designs. The class of t-designs with parameter (λ, t, r, n) is denoted as S λ (t, r, n); a valid t-design in S λ (t, r, n) is a pair (X, B) where X is n-element set and B is a collection of r-element subsets of X with the property that every element in X appears in exactly γ blocks and every t-element subset of X is contained in exactly λ blocks. Without loss of generality, one can always use X = I n , and we shall use this convention from here on.
The most extensively researched class of block designs is perhaps Steiner systems, which is the case when λ = 1 and t ≥ 2. In this case, the subscript λ is usually omitted and we directly write it as S(t, r, n).
The simplest design in this class is when t = 2 and r = 3, which is the particularly well understood Steiner triple systems S(2, 3, n). It is known that there exists a Steiner triple system S(2, 3, n) if and only if n = 0, or n modulo 6 is 1 or 3; see, e.g., [13]. It follows that the smallest positive integer which February 20, 2013 DRAFT  TABLE I  EXAMPLE STEINER TRIPLE SYSTEMS S(2, 3, 7), S(2, 3, 9) AND S(2, 4, 13).
For a given (λ, t, r) triple, a t-design may not exist for an arbitrary n, however, for any (t, r, n), a trivial t-design always exists with λ * (t, r, n) n−t r−t , as given in the following proposition. Proposition 1: For any (t, r, n) where t ≤ r ≤ n, a complete block design is a block design where the blocks are all the r-element subsets of I n (and the blocks are not repeated). In this design every element in I n appears in exactly n−1 r−1 blocks and every t-element subset of X is contained in exactly λ * (t, r, n) blocks.
We may still refer to such a complete block design for the case of t = 2 as a BIBD, although it is in fact a complete block design instead of an incomplete one. The following proposition [13] is useful.
then the number of blocks containing S is The following corollary apparently follows by setting s = 0 in Theorem 2.
For the case of Steiner systems, we shall omit the subscript, and simply write it as N (t, k, n). When the parameters are clear from the context, we may also write N λ (t, r, n) as N * .
There are various known constructions, existence results, and non-existence results for Steiner systems, BIBDs and t-designs in the literature; interested readers are referred to [13] and [14] for more details.
To illustrate the basic code components, we shall construct a (9, 7, 8) exact-repair regenerating code with M = 23, α = 4 and β = 1. The addition and multiplication operations in the encoding and decoding are in the finite field F(3), however this choice is only for better concreteness. The construction is based on the block design S (2,3,9) given in Table I.
Let the information be given as a length-23 vector, where the i-th entry is denoted as d i ∈ F(q). The components of this code are given described below.

Encoding:
1) Generate a parity symbol d 24 = 12 3) Generate a new parity symbol P j = X j + Y j , and (X j , Y j , P j ) will be referred to as a parity group, where j = 1, 2, . . . , 12; 4) For each block B j = {b j,1 , b j,2 , b j,3 }, j = 1, 2, . . . , 12, in the block design, write one symbol in j-th parity group in the b j,1 -th disk, one in the b j,2 -th disk, and one in the b j,3 -th disk, respectively.
One possible resulting code symbol placement is illustrated in Table. II. The placement is not unique, since within each parity group, the symbols can be permuted arbitrarily. Note that the second step above is for facilitating better understanding, and a more concise set of notations will be used in the general construction in the next section.

Repair:
Let us suppose the first disk fails. To regenerate, for example, symbol X 5 , first obtain Y 5 and P 5 from disk-3 and disk-5, respectively, and then compute X 5 = P 5 − Y 5 . Clearly, other symbols on the disk can also be repaired following a similar procedure. This procedure also applies to other disk failures. It can also be checked that for any disk failure, each remaining disk sends a single symbol during the repair, which is in fact guaranteed by the basic property of block designs in this case.

Reconstruction:
For data reconstruction, several different cases need to be considered. Before going into the details of these cases, consider a scenario where disk 1 and disk 2 are not accessible. Notice that although (X 1 , X 4 , X 5 , X 7 , X 8 , X 9 , Y 9 , P 3 ) are not accessible directly, (X 1 , X 4 , X 5 , X 7 , X 8 , P 3 ) can be recovered using the symbols on other disks, as discussed in the repair procedure above; thus parity groups 1, 2, 3, 4, 5, 6, 7, 8 are not effected. As a consequence, only symbols in the 9-th parity group can not be completely recovered, but even in this parity group, P 9 is still accessible on disk-6. The reconstruction cases can be classified according to which parity group is effected (i.e., cannot be completely recovered directly) and which symbol within this parity group is still accessible.
1) The j-th parity group, i ∈ I 11 , is effected, but X j or Y j is still accessible within it. An example case is when disk-3 and disk-4 are not accessible. Note X 1 = d 1 is still available in this case, can be solved. The information vector can be obtained by rearranging the symbols.
2) The j-th parity group, j ∈ I 11 , is effected, but the parity symbol P j is still accessible within it.
Let us compare this code with the time-sharing code using an MBR code and an MSR code. For This example illustrates the main components in the proposed construction, i.e., a block design, a first layer long MDS code, and a second layer short MDS code. The coefficients used in the two parity symbols of the two codes cannot be set arbitrarily, for example, if we were to set P j = X j + 2Y j , then in the second case discussed in the reconstruction procedure, a decoding failure would occur. The basic idea is to use the short MDS code to recover as many data symbols as possible which will render most of the parity symbols in the short MDS code redundant, and then use the remaining parity symbol in the short MDS code together with the parity symbol in the long MDS code to jointly solve the remaining unknown data symbol.

IV. CODE CONSTRUCTIONS
In this section, we first describe an explicit code construction for (n, n−2, n−1) code based on Steiner system S(2, r, n). This construction however only applies to the case when a Steiner system exists for such n, and as aforementioned, Steiner systems may not exist for all (r, n) pairs. Then based on BIBDs S λ (2, r, n), the method is generalized to the case any (n, k, d) triples such that k ≤ n − 1 and d = n − 1.
Since a complete block design can be viewed as a special case of BIBDs, the construction applies to any value of positive integer n. This construction can be further generalized to the case when d < n − 1, which will be discussed briefly.

A. A Construction Based on S(2, r, n)
Given a block design (I n , B) ∈ S(2, r, n), the exact-repair regenerating code with parameters (n, k, d) = (n, n − 2, n − 1) we shall construct has the following parameters where we have used N * to denote N (2, r, n) for notational simplicity. Note that these parameters are all integers for a valid Steiner system, moreover, n(n − 1) is a multiple of r(r − 1), which can be seen using Proposition 2 and its corollary. The alphabet for this code can be chosen to be any finite field F(q) with a field size q ≥ r, and the addition and multiplication operations in the encoding and decoding process are performed in this field.

Repair:
Suppose disk-m fails. In order to recover the symbols on this disk, find in B all blocks B j such that m ∈ B j . Recall there are a total of α such blocks, and let them be denoted as B k1 , B k2 , . . . , B kα . For each of this block B kl , l = 1, 2, . . . , α, obtain the symbols in the parity group k l from the disks in the set B kl \ {m}, and recover the symbol in this parity group on disk-j using the relation (18).

Reconstruction:
Several cases need to be considered, when two disks have failed: 1) The j-th parity group loses two symbols which are the parity symbol P j and one data symbol D i,j , and the other parity groups each lose one symbol or less. This implies that the other parity groups can recover all its data using (18), and thus only D i,j needs to be recovered. It can be obtained through D r−1,N * , by eliminating in (17) the symbols in the other parity group, and then eliminating D k,j , k = i.
2) The j-th parity group loses two symbols which are two data symbols D i1,j and D i2,j , and the other parity groups each lose one symbol or less. Other data symbols can be obtained as in the previous case, and only D i1,j and D i2,j need to be recovered. Since D r−1,N * is still available, by eliminating the symbols in the other parity group in (17), and then eliminating D k,j , k = i 1 and (18), we obtain D i1,j + D i2,j . Since φ i1 = φ i2 and they are both non-zero, D i1,j and D i2,j can be solved using these two equations.
3) Parity group N * loses two symbols, which are the parity symbols D r−1,N * and P N * . This case is trivial since all data symbols have been directly recovered. 4) Parity group N * loses two symbols, which are the parity symbols P N * and a data symbol D i,N * , By eliminating the symbols in the other parity group in D r−1,N * using (17), and then eliminating D k,N * , k = i, we obtain D i,N * . 5) Parity group N * loses two symbols, which are the parity symbols D r−1,N * and a data symbol Note that P N * is still available and By eliminating the symbols in the other parity group in P N * and then eliminating D k,N * , k = i, The code construction is illustrated in Fig. 2. In the disk repair and data reconstruction procedure given above, we have inherently assumed that the following two facts hold: • Fact one: During the repair, each remaining disk contributes exactly one symbol; • Fact two: When two disks are not accessible, only one parity group has two inaccessible symbols, and the other parity groups each have only one symbol or less inaccessible symbol.
These are indeed true by invoking the basic property of Steiner system, more precisely, that any pair of elements in I n appears exactly in one of the blocks in B.
The long code in the construction is an (M + 1, M ) systematic MDS code whose parity symbol is specified by (17), and the short code is a (r, r −1) systematic MDS code whose parity symbol is specified by (18). It should be noted that the coefficients in forming the parity symbols are certainly not unique, and we have only given a convenient choice here. In many cases, the performance of codes is better than time-sharing between MSR and MBR points, however, we leave the detailed analysis to the next section to avoid repetition.

B. A Construction Based on BIBDs S λ (2, r, n)
In this subsection, we generalize the construction previously described to the setting of exact-repair regenerating codes for any positive integer n, d = n − 1 and any k ≤ n − 1, based on BIBDs S λ (2, r, n).
The validity of the construction relies on application of the Schwarz-Zippel lemma, which is used to show that there exists a valid choice of long MDS code when the alphabet is large than a given threshold.
First fix a BIBD (I n , B) ∈ S λ (2, r, n), and again denote N λ (2, r, n) as N * . First define the quantity where A ⊂ I n and |A| = n − k, then further define The relevance of this quantity will become clear shortly. When n − k = 2, the definition of BIBDs gives T = λ. The construction given in the previous subsection belongs to this case with T = λ = 1. In general, the quantity is dependent on the particular block design, and does not appear to have an explicit formula, however, we shall discuss a bound on this quantity in the next section.
The code we construct has the following parameters Note that although α is always an integer, (n − 1) is not necessarily a multiple of r − 1 here, unlike in the previous construction. This implies thatᾱ may not be an integer.
Let the M information symbols in F(q) be given in a vector d, and use it to fill the first M entries in a (r − 1) × N * matrix D following the column-wise order, i.e., the first column (top-down), and the second column, etc.; the rest of the T -entries of the matrix are left blank. The code requires a matrix S of size T × M , whose entries are also in F(q). The matrix S is used to generate the parity symbols for the long MDS code, and we shall specify the condition for S shortly.

Encoding:
The encoding procedure is similar to the procedure given in the previous subsection, with the only difference being that we first compute the multiplication S · d and then fill the rest of D matrix using the resultant T parity symbols in a column-wise manner.

Repair:
The repair is precisely the same as the repair procedure given in the previous subsection. Note that each remaining disk contributes exactly λ symbols, which is implied by the definition of S λ (2, r, n).

Reconstruction:
Let (n−k) disks in the set A be inaccessible, where |A| = n−k. For each parity group j = 1, 2, . . . , N * , construct a length-r vector z i as follows • If B j ∩ A ≤ 1: collect, and if necessary, compute using (18), the symbols D i,j , i = 1, 2, . . . , r − 1; let z j = (D 1,j , D 2,j , . . . , D r−1,j , 0) t ; • If B j ∩ A ≥ 2: collect the available symbols in this parity group, denoted as (D i1,j , D i2,j , . . . , D il,j ), assign D i1,j , D i2,j , . . . , D il,j to the i 1 , i 2 , . . . , i l positions of vector z j , and let the rest of z j be zeros. This construction is illustrated in Fig. 3, from which the difference and similarity from the construction given in the previous subsection is straightforward. For the case r = 2, the proposed construction is precisely the repair-by-transfer construction in [5]. In this case, the parity symbol P j is a simple repetition, and the S λ (2, 2, n) design is when λ = λ * = 1 in the trivial complete design.

Finally letd
Next we show that a matrix S with the desired properties indeed exists. Note that as long as the transfer matrix betweend A and d has rank M , the information vector d can be correctly reconstructed.
To identify this matrix, first construct a template matrix R of size r × (r − 1) as R = [I, 1 t ] t , where I is the identity matrix, and 1 is the all one vector of length r − 1. For each j = 1, 2, . . . , N * , construct matrix R j of size r × (r − 1) as follows, • If B j ∩ A ≤ 1, let R j be R with the last row set to all zeros; Finally form a matrix Q A of size (rN * ) × (r − 1)N * using matrix R j 's as the diagonal, i.e., Clearly, we have where G = [I, S t ] t . Thus as long as Q A · G has rank M for each set A ⊂ I n such that |A| = n − k, the information vector d can be correctly decoded no matter which n − k disks are inaccessible. We have the following proposition.
Proposition 3: Among the q T M distinct assignments of S, at most a fraction of q −1 n k T M may induce a matrix Q A · G with rank less than M for some A ⊂ I n such that |A| = n − k.
Proof: The proof is a direct application of the Schwartz-Zippel lemma in its counting form. For each A ⊂ I n such that |A| = n − k, if we can show that the fraction of assignments resulting in rank(Q A · G) < M is bounded by q −1 T M , then the bound given in the proposition is obtained by a simple union over all choices of A. To show this, first remove the all-zero rows in Q A , and then remove the first T − T (A) rows in the remaining matrix, resulting in a matrix Q ′ A . Note that Q ′ A · G is of size M × M , and thus as long as Q ′ A · G has full rank, the matrix Q A · G has rank M . However, Q ′ A · G having full rank is equivalent to det(Q ′ A · G) = 0. Since det(Q ′ A · G) is a polynomial g(·) of the entries of S, as long as g(·) is not identically zero, we can apply the Schwartz-Zippel lemma and conclude the proof. The polynomial g(·) is indeed not identically zero, which is proved in the appendix.
As a consequence of this proposition, when q > n k T M , there exists at least one valid choice of matrix S; in fact, when q is sufficiently large, almost all the assignments of S are valid. The problem of explicitly constructing the matrix S is open, however it may not be as complex as it seems. One possible approach is to let S be the parity portion of a systematic MDS code generator matrix, and then check whether the full rank conditions are satisfied for each possible set A ⊂ I n with |A| = n − k, which is a total of n k conditions.

C. A Construction Based on t-Designs S λ (t, r, n)
The code construction for exact-repair regenerating codes presented in the previous section can be generalized to the case d < n − 1, by using general t-design instead of BIBDs. The resulting codes may require different amounts of data contributions from disks during repair, and thus do not strictly belong to the class of codes defined in Section II. For this reason, instead of considering per-disk rate β during repair, we shall only consider total repair bandwidth γ here. A special class of code, based on complete block designs S λ * (t, r, n), can be made symmetric by time-sharing among different repair rate allocations, as shall be discussed shortly.
Given a particular t-design (I n , B) ∈ S λ (t, r, n), we shall construct an exact-repair regenerating codes of parameter (n, k, d) using (X, B), where d = n − t + 1 and k ≤ d. Similarly as in the last subsection, define the quantity where A ⊂ I n and |A| = n − k, then further define The code we construct has the following parameters (note instead of β, here γ is given) The difference from the construction given in the last section is that instead of only one parity symbol, t − 1 parity symbols P 1,j , P 2,j , . . . , P t−1,j are generated in the parity group j, using a fixed systematic (r, r − t + 1) MDS code; see Fig. 4. Any symbol on a failed disk has a maximum of n − d = t − 1 symbols from the same parity group that are not participating in the repair, however the (r, r−t+1) MDS code guarantees that this symbol can be recovered using the remaining at least r − t + 1 symbols on the other disks. Note that the amounts of data contributions from these disks are in general not symmetric, although there may be many choices to choose which symbols to use in the repair. Similarly as in the previous case, it can be shown that there exists a matrix S of size T × M which guarantees correct decoding in a sufficiently large alphabet, and thus we omit the details to avoid repetition.
One particularly interesting case is when the complete block design S λ * (t, r, n) is used. In this case, although the data contributions from the disks during repair may not be symmetric, one can always time-share among different helper rate contribution allocations, due to the symmetry of the code. Thus this time-sharing version of the codes based on complete block design indeed belongs to the class of codes defined in Section II.

V. PERFORMANCE ANALYSIS
In this section, we analyze the performance of the proposed codes more systematically. Recall that the quantity T includes an optimization problem, and it is block design dependent. Thus in general (α, β, M ) of a particular code can not be explicitly evaluated. However, for the codes based on complete block designs, the performance can indeed be explicitly evaluated. Moreover, for any given (r, n), a complete block design S λ * (2, r, n) in fact offers the best performance among all possible BIBDs S λ (2, r, n), in terms of the normalized measure (ᾱ,M ), which is shown next.

A. The Optimality of Complete Block Designs
Proposition 4: Given an (n, k, d) code C 1 constructed using t-design of (I n , B) ∈ S λ (n − d + 1, r, n), which achieves (ᾱ,M 1 ), and an (n, k, d) code C 2 constructed using the complete design S λ * (n − d + 1, r, n), which achieves (ᾱ,M 2 ). ThenM 1 ≤M 2 , with inequality holds if and only if in (I n , B) the quantity T A is uniform for all set A ⊂ I n with |A| = n − k.

Proof:
The T function on both (I n , B) ∈ S λ (n − d + 1, r, n) and on the complete design S λ * (n − d + 1, r, n) need to be considered, and in order to distinguish them, we shall the latter as T * .
Consider the block design resulting from a permutation π of the elements of I n , which also operates on the blocks in (I n , B), and denoted the T (A) function on this permuted block design as T π (A), and the T function on this permuted block design as T π . Construct a new and larger block design by taking all the blocks resulting through the n! permutation of the design (I n , B); note that there might be repetition of the same blocks, which is allowed in this new design. We shall denote the T (A) function operating on this new design as T p (A), and the corresponding T function as T p .
This new compound design is apparently a complete block design where each block is repeated n!λ λ * times, and thus However, since it is the combination of n! permutation of the block design (I n , B), we also have Thus λ * T ≥ λT * , which when combined with (15) and (27), givesM 1 ≤M 2 . Clearly equality holds if and only if T π (I n−k ) = T for all π, which is equivalent to T (A) = T for all A ⊂ I n with |A| = n − k.
The proof is complete.
Although complete block designs provide the best (ᾱ,M ) among all the t-designs in the same class, other incomplete block designs may lead to simpler code, as illustrated in the following example.
The S matrix for the first layer code in this case is of size 7 × 161, i.e., 7 parity symbols generated by 161 information symbols. In contrast, in the example given in Section III, also a (9, 7, 8) exact-repair regenerating code, has a first layer code with only a single parity symbol, generated by 23 information symbols. Note however both code achieve the same normalized measure (ᾱ,M ) = (4, 23).

B. Performance Analysis Using Complete Block Designs
Recall that S λ * (t, r, n) can be used to construct codes with different k values, where t = n − d + 1.
With complete block designs, the value T can be explicitly evaluated as follows using the symmetry It is clear that the code has a normalizedᾱ as and a normalizedM asM Clearly forᾱ ≥ 0, we need r ≥ n − d + 1. Since at the MSR point,ᾱ = d − k + 1, it is more meaningful to choose However, choosing r greater than this value is also valid, which may yield codes that although not efficient in terms of (ᾱ,M ), but nevertheless useful due to its simplicity.
There does not seem to be any simplification for specific (n, k, d) parameters. We provide a few examples to illustrate the performance of the code for various (n, k, d). In Fig. 5, we plot the performance of the proposed codes for the case of (n, k, d) = (9,7,8), and for reference the cut-set bound and timesharing line are also included. It can be seen that in addition to the code example given in Section III, there is one more parameter r = 4 that yields a performance above the time-sharing line; the proposed code also achieves the point (8,35), which is not surprising since in this case it reduces to the optimal construction in [5]. The operating point (ᾱ,M ) = (2, 13.4) is worth noting, because although it is not as good as the MSR point (2,14), the penalty is surprisingly small. This suggests that the proposed codes may even be a good albeit not optimal choice to replace an MSR code, particularly when such MSR codes have high complexity.
In Fig. 6 we plot the performance of codes for different parameters (k, d) when n = 24. It can be seen that when d = n − 1 = 23, the performance is the most competitive, and often superior to the time sharing line. As d value decreases, the method become less effective in terms of its (ᾱ,M ), and becomes worse than the time-sharing line. For the same d value, the code is most effective when k is large, and becomes less so as k value decreases. It should be noted that the lower left corner is the MSR point, and in a wide range of parameters the proposed scheme in fact operates rather close to it, despite the simple coding structure.

C. An Asymptotic Analysis
In this subsection, we consider the asymptotic performance of the proposed codes when n is large.
Recall the case under consideration is when k = n − τ 1 and d = n − τ 2 where τ 1 and τ 2 are fixed constant integers. We have the following theorem.
Theorem 3: Let E * be the collections of (E r , E d ) pair such that Then E * = E, and moreover, E * can be asymptotically achieved by the proposed code construction.
Proof: We first show that E ⊆ E * by utilizing the cut-set bound in Theorem 1. For better clarify, we shall write (ᾱ,M ) for a fixed n explicitly as (ᾱ (n) ,M (n) ). First notice that the bound implies that for any integer c ∈ [0, k] Taking which implies that and thus for any (E r , E d ) ∈ E, E d ≤ 2. By taking c = k, we havē which implies that It follows that and thus E r − E d ≥ −1 for any (E r , E d ) ∈ E. Next rewrite (36) when as follows where the second inequality is due to (39). Rearrange the right hand side of the above inequality to be a quadratic function in c, we have When the following condition holdsM that is we can choose and arrive at the bound This implies that when (45) is true, for any sufficiently large n and any δ > 0 and thus E r ≥ 2E d − 2 when E d ≥ 1. This completes the converse proof.
For the forward proof, we shall first fix a quantity 0 < ǫ < 1, and consider a sequence of code n = n 0 , n 0 + 1, . . .. From (32), we get Note that Thus from (33) we haveM This implies that for any δ > 0 and sufficiently large n, there exists a code using the proposed design which implies that for any δ > 0 and sufficiently large n, there exists a code using the proposed design such that E (n) r ≤ 2 − 2ǫ + δ. Because the region E is a closed set, it follows that the pair is achievable for any 1 > ǫ > 0, and thus the region 2E d ≤ 2 + E r is achievable for any 2 > E r > 0. The case (E r , E d ) = (0, 1) can be simply addressed by taking a sequence of ǫ m such that ǫ m → 1; the case of (E r , E d ) = (2, 2) can be addressed similarly. The regions when E r > 2 and E r < 0 are degenerate and they are easily shown achievable either by increasing unnecessarily the redundancy in the code, or increasing unnecessarily the amount of repair bandwidth. The proof is thus complete.
For comparison, let us consider the time-sharing scheme between an MSR and an MBR code. Note that the MSR point corresponds to (E r , E d ) = (0, 1) and MBR point corresponds to (E r , E d ) = (2, 2).
For a code using a time-sharing weight θ (n) , the rate can be bounded as and the redundancy can be bounded as For any sequence of such a time-sharing codes index by n, we have which implies that for any δ > 0 and sufficiently large n, and it follows that E r ≥ E d when E d ≥ 1. Using (62) and (63), we can also write which implies that when E r ≤ 1, we must have E d ≤ 1 using the time-sharing strategy. See Fig. 7 for an illustration of this region.
The gap between E and the time-sharing scheme shows that the improvement of our proposed codes over the time-sharing scheme increases with n, and it can be unbounded.

VI. CONCLUSION
A new construction for (n, k, d) exact-repair regenerating codes is proposed by combining two layers of error correction codes together with combinatorial block designs. The resultant codes have the desirable "uncoded repair" property where the nodes participating in the repair simply send certain stored data without performing any computation. We show that the proposed code is able to achieve performance better than the time-sharing between an MSR code and an MBR code for some parameters. For the case of d = n − 1 and k = n − 2, an explicit construction is given in a finite field F(q) where q is greater or equal to the block size in the combinatorial block designs. For more general (d, k) parameters, we show that there exist systematic linear codes in a sufficiently large finite field.

APPENDIX
In this appendix, we prove det(Q ′ A · G), as a function of the entries of the matrix S, is not identically zero. For this purpose, we shall revisit the matrix Q A . Set the first T − T (A) non-zero rows in Q A to be all zeros, and denote the resulting matrix as Q * A ; let us omit the subscript A from here on for simplicity. If there exists an assignment of S such that Q * · G has rank M , then clearly det(Q ′ · G) = 0, since Q ′ is simply Q * without the all-zero rows.
Recall the matrix Q * is of size (rN * ) × (M + T ) with M non-zero rows, and the matrix G is of size where Q 11 is of size (ar + b) × (a(r − 1) + b), which implies Q 12 is an all-zero matrix. It follows that In order to show Q * · G has rank M , our plan is to specify an auxiliary matrix H, which satisfies the following two conditions.
• Condition one: the matrix [Q t 11 , H t ] has rank M ; • Condition two: the equation H = Q 21 + Q 22 · S has a valid solution for S.
Clearly, if both these two conditions hold, the proof is essentially complete.
We start by first assuming that there exists at least one all-zero row in the bottom r − b rows of R a+1 ; the other case will be addressed shortly. A set of (a + 1) intermediate matrics H 1 , H 2 , . . . , H a+1 shall be constructed as follows. For j = 1, 2, . . . , a, find the all-zero rows in R j , and denote the indices as l 1 , l 2 , . . . , l ej ; if e j ≥ 2, then the matrix H j is of size (e j − 1) × M , where the i-th row has all zeros except the (j − 1)(r − 1) + l i position, which is assigned 1. For j = a + 1, find the all-zero rows in the first b rows of R a+1 , denote the indices as l 1 , l 2 , . . . , l ea+1 ; the matrix H a+1 is of size e a+1 × M , where the i-th row has all zeros except the a(r − 1) + l i position, which is assigned 1. To see that condition one holds, notice that in matrix H, by exchanging the rows (j − 1)r + l 1 , (j − 1)r + l 2 , . . . , (j − 1)r + l ej−1 in Q 11 (i.e., the rows corresponding to the first e j − 1 all-zero rows in R j ) and the rows of H i , each block matrix R j can have rank r − 1; by similar operation, the top b rows of matrix R a+1 is an identity matrix. Due to the block diagonal structure of the matrix Q 11 , this indeed implies that the matrix [Q t 11 , H t ] has rank a(r − 1) + b = M . To see that condition two also holds, we solve for S block by block. First consider the block R N * in Q 22 , and assume N * > a + 1. Due to the block structure of Q 22 , the determination of the last (r − 1) rows of S only depends on R N * and the last r rows of H, but not any other entries in Q * and H. Let us denote the sub-matrix consisting of the last r − 1 rows of S as S ′ , and denote the sub-matrix consisting of the last r rows of H as H ′ . The problem essentially reduces to finding a solution for R N * · S ′ = H ′ .
Denote the indices of the rows which have non-zero entries in R N * as i 1 , i 2 , . . . , i e , then the column span of R N * is the space spanned by columns with a single 1 at the i 1 , i 2 , . . . , i e positions; this further relies on the structure of R N * and the fact that there is at least one all-zero row in it. It follows that the column span of H ′ is in the column span of R N * , and thus there indeed exists a solution for S ′ . Repeat this process for the other blocks, as well as the partial block of R a+1 in Q 22 , a solution for S is found.
The case that there exists no all-zero row in the bottom r − b rows of R a+1 introduce the complication that for the partial block of R a+1 in Q 22 , because in this case its column span is one-dimension less than the space spanned by columns with a single 1 at the desired positions. However, the only change required is the following: the (r − b)-th row of H is chosen to be the summation of its first (r − b − 1) rows and the (r − b)-th row of Q 21 . It is straightforward to check that both condition one and condition two can still be made to hold for this case. The proof is complete.