{'fraction_non_alphanumeric': 0.047502121983751665, 'fraction_numerical': 0.010822117133503091, 'mean_word_length': 4.042647508407215, 'pattern_counts': {'":': 0, '<': 5, '<?xml version=': 0, '>': 27, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 15, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Exact Scalar Minimum Storage Coordinated Regenerating Codes

We study the exact and optimal repair of multiple failures in codes for distributed storage. More particularly, we examine the use of interference alignment to build exact scalar minimum storage coordinated regenerating codes (MSCR). We show that it is possible to build codes for the case of k = 2 and d>k by aligning interferences independently but that this technique cannot be applied as soon as k>2 and d>k. Our results also apply to adaptive regenerating codes.


I. INTRODUCTION
Codes allow to implement redundancy in distributed storage systems so that device failures do no hurt the whole system. Yet, to keep preventing failures, once failures have occurred, codes must be repaired: the redundancy level must be kept above some minimum level. The naïve approach to repairing codes consists in decoding the whole code (thus downloading all blocks) so as to encode it again to recreate the few lost blocks. This induces huge repair costs in term of network bandwidth. It has recently been shown that this repair cost can be significantly reduced by repairing without decoding using regenerating codes. Lower bounds on costs (i.e., tradeoffs between storage and bandwidth) have been established for both the single failure case [1], [2], and the multiple failures case [3]- [5]. Adaptive regenerating codes, departing from the other studies by allowing the number of devices involved to differ between repairs, have been defined in [3]. The two extreme points of the optimal tradeoffs are Minimum Bandwidth (MBR/MBCR), which minimizes repair cost first, and Minimum Storage (MSR/MSCR), which minimizes storage first. Codes matching these theoretical tradeoffs can be built using non-deterministic schemes such as random linear network codes.
However, non-deterministic schemes for regenerating codes are not desiderable since they (i) require a great field size, (ii) require homomorphic hash functions to provide basic security (integrity checking), (iii) cannot be turned into systematic codes, which offer access to data without decoding, and (iv) provide only probabilistic guarantees. Deterministic schemes overcome these issues by offering exact repair (i.e., during a repair, the regenerated block is equal to the lost block and not only equivalent). For the single failure case (t = 1), code constructions with exact repair have been given for both the MSR point (n, k, d ≥ 2k − 2 [6] and n, k, d when the size of the file is infinite [7], [8]) and the MBR point (n, k, d [6]) where n is the number of encoded blocks, k is the number of original blocks, and d is the number of devices contacted during repairs. Recent works on this problem are surveyed in [9]. However, the existence of codes supporting the exact repair of multiple failures (t > 1) (i.e., exact coordinated/adaptive regenerating codes) is an open question.
In this paper, we focus on this problem, thus extending our previous work on coordinated regenerating codes in [3] with exact repair. We consider the case of n, k, d > k, t > 1 for scalar constructions (i.e., β = 1) and make the following contributions: • In the line of exact scalar minimum storage regenerating codes [6], [10], [11], we propose exact scalar minimum storage coordinated regenerating codes (MSCR) for the case n, k = 2, d ≥ k, t = n − d. This interference alignment based construction is inspired by [10], [11].
(Section III) • Inteference alignment has been applied to scalar MSR codes by aligning the various interferences independently. We show that when k ≥ 3, aligning interferences independently, as in [10], [11], is not sufficient to repair exactly scalar MSCR codes. (Section IV). Note that these results, which correspond to the MSCR point, also apply to exact scalar adapative regenerating codes [3].
As explained earlier, most previous works have been limited to single failures (t = 1). For the multiple failures, there only exist results for the case n, k, d = k, t = n − k, a degenerated case where the repair of regenerating codes and the naïve approach to repairing erasure correcting codes are the same. In this case, the exact repair of MSCR boils down to performing, in parallel, the repair of t independent erasure correcting codes [5]. A similar construction exists for MBCR codes [12]. The position of our codes among existing codes constructions is detailled in Section V.

II. BACKGROUND
We consider a n devices system storing a file of M bits. The file is encoded and dispatched accross all n devices (each storing α bits) so that the file can be recovered by collecting data from any k devices. Whenever devices fail, they must be repaired so that the level of redundancy does not fall bellow a critical level. Classical erasure correcting codes require a decoding to be performed to repair any single lost block by encoding the decoded data and dispatching again. This approach has huge repair costs (in term of network communications). It has been shown that this cost can be significantly reduced by relying on regenerating codes [1], [2].
Collect Store (1,1) (1, 1) Figure 1. Regenerating codes can be repaired functionally or exactly. In our example, the device storing (a 1 , a 2 ) fails and is regenerated. When relying on functional repairs, the information about (a 1 , a 2 ) is regenerated but not in the same form, while when relying on exact repairs, (a 1 , a 2 ) is regenerated exactly. This figure also illustrates the difference between scalar codes where scalar are transmitted over the network and vector codes where vectors are sent over the network.
Similar results have been given for repairing multiple failures using coordinated/cooperative regenerating codes [3]- [5]. For repairing coordinated regenerating codes, each failed device 1 contacts d ≥ k live devices and gets β bits from each. The t failed devices coordinate by exchanging β bits. The data is then processed and α bits are stored. The amounts of data exchanged and stored during repairs are summarized on Figure 2. These studies lead to the definition of the optimal tradeoffs between storage α and repair costs γ = dβ+(t−1)β . The two extreme points of the optimal tradeoffs are shown on Figure 3 with the corresponding values of α, β and β . The MSCR (resp. MBCR) point minimizes storage (resp. bandwidth) first. In this paper, we will focus on MSCR constructions for they are very close to classical erasure correcting codes and are highly related to adaptive regenerating codes.
Coordinate Store Figure 2. Amounts of information exchanged during the repair of t failed devices from d live devices (an infinite capacity means that all the information received is kept for later processing). During a first step, each failed device collects β bits from d live devices. All failed devices coordinate by exchanging β bits. The data is processed and α bits are stored. Solid lines show transfers over the network.
These tradeoffs are derived from network coding results, through a reduction to a multicast problem. Hence, nondeterminstic coding schemes matching these tradeoffs can be built using random linear network codes. The corresponding non-deterministic repairs are termed as functional repairs. Yet, such codes have several disadvantages: (i) they have high decoding costs, (ii) they make the implementation of integrity checking complex by requiring the use of homomorphic hashes, (iii) they cannot be turned into systematic codes, which provide access to data without decoding, and (iv) they can only provide probabilistic guarantees.
Exact scalar codes n, k, d ≥ 2k − 2, t = 1 [6] n, k, d = k, t > 1 [5] Storage Repair bandwidth Figure 3. Regenerating codes achieve the optimal tradeoff between storage and bandwidth (i.e., repair cost). The figure shows the values for the MSCR and MBCR points. The figure also shows the best exact scalar regenerating codes (β = 1) known for the single (t = 1) and multiple failure cases (t > 1).
To this end, it has been proposed to study deterministic schemes, namely exact regenerating codes, regenerating blocks equal to the lost ones instead of blocks only functionally equivalent. The difference between exact repair and functional repair is shown on Figure 1. It has been shown that exact repair is strictly harder than functional repair [11], which means that the existence of functional regenerating codes does not imply that exact regenerating codes exist. Hence, an interesting question is whether the previous tradeoffs, which apply to functional repairs, can still be achieved for exact repairs. The problem of repairing exactly a single failure has been well studied [6]- [11], [13], [14], including intermediary repair schemes such as semi-exact repairs where only a part of the data is regenerated exactly [15]- [18]. However, the exact repair of multiple failures has been studied mostly according to functional repairs [3]- [5] except for the very specific setting d = k [5], [12].
In this article, we consider only scalar codes where one indivisible sub-block is transmitted between devices during repairs (i.e., β = 1), thus leading to simpler constructions ( Figure 1b). When considering the exact repair of single failures, it has been shown that scalar codes are sufficient to construct MBR Figure 4. Exact Repair of the systematic part of an MSCR code (n = 5, k = 2, d = 3, t = 2). The state of the system after the storing step is not shown but it is clear that the first device can recover a and that the second one can recover b.
codes for any value of n, k, d and MSR codes for any values n, k, d ≥ 2k − 2. However, scalar codes are not sufficient for building exact scalar MSR codes when d < 2k − 3 [10]. The discussion of vector codes constructions, in which multiple indivisible sub-blocks are transmitted between devices during repairs (i.e., β > 1) (Figure 1c), is deferred to Section V about related work.
In the sequel of the article, we will study the exact repair of regenerating codes when multiple failures occur. We study the non-degenerated case of d > k and use scalar codes (β = 1). We adopt following convention: the data v and the codewords w are column vectors, the generator matrix G is rectangular and the encoding operation w = Gv gives a column vector.

III. EXACT MSCR CODES FOR k = 2
In this section, we provide a code construction for scalar MSCR codes supporting exact repairs for d > k, k = 2 and t = 2. This code construction also serves as a proof that its possible to repair exactly a (n, k = 2, d = n − t > k, t = 2) MSCR code. We consider a system storing a file of size M = k(d−k+t) split in k = 2 blocks (a, b), each of size α = d − k + t subblocks. The system consists of n = d+t devices as we assume that all failed devices and all live devices take part to the repair. In the sequel of the article, we consider a finite field F having a generator element ω.
The system is compounded of two devices storing the systematic part and s = n − 2 devices storing the redundancy part.
• The first systematic device stores a = (a 1 , . . . , a α ) t . • The second systematic device stores An example for k = 2, d = 3 and t = 2 is given on Figure 4. Using the previously defined code, we can state the two following theorems: Theorem 1. It is possible to build minimum storage coordinated regenerating codes that can be repaired exactly when n = d+t (i.e., all devices participate in the repair 2 ), k = 2 and t = 2 (i.e., multiple repairs are performed simultaneously).
Proof: In the sequel of this section, we review the different properties that are needed for this code to be an MSCR code: • It must be an MDS code (i.e., data from any k = 2 devices must allow recovering the original data). • Any two devices can be repaired exactly.
The theorem follows from the code satisfying these properties. Theorem 2. It is possible to build adaptive regenerating codes that can be repaired exactly when n = d + t (i.e., all devices participate in the repair 3 ), and k = 2.
Proof: In order to show that there exists adaptive regenerating codes [3], that can be repaired exactly, we need to find a code that has the following properties.
• It must be an MDS code (i.e., data from any k = 2 devices must allow recovering the original data). • Any two devices can be repaired exactly. • Any single failure can be repaired exactly.
The theorem follows from the code satisfying these properties. Note that the two first properties are common with the proof of Theorem 1.

A. The MDS property
This property is trivially satisfied since, when fetching data from any two devices, we get α groups of 2 equations over 2 unknowns, where each group concerns different unknowns. The i th group is about a i and b i and consists of 2 independent equations. Hence, the unknowns of each group can be recovered and the MDS property is satisfied.

B. Repairing two failures
The repair consists of the following steps, which map onto the process defined in [3]. In this scheme, illustrated in Figure 5, we do not rely on random linear network coding but give a method for repairing exactly. Figure 5. The repair process, with a coordination step. Interfering information transmitted is aligned to allow the recovery of a and b.
1. Identify lost data. Prior to performing the repair, the system identifies which devices have failed and which blocks have been lost. Given the failure of any two devices (systematic or redundancy), we perform a change of variables to transform the actual code C into a code C , in which the failed devices are the systematic ones storing a = (a 1 . . . a d ) t Such a code is guaranteed to exist since the original code is MDS (same argument as in [10]). Furthermore, the system identifies two spare devices than can host the repaired blocks replacing the lost ones.
2. Prepare (Collect). Each live device that participates to the repair computes a sub-block to be sent to the first device and a sub-block to be sent to the second device. All the subblocks to be sent to the first device have the common property that the interfering information about b is aligned (i.e., the i-th live device, storing r i , sends 4 v αi r i = w αi a + z α b so that the spare device receives different information about a but the same about b. To build v αi , given some arbitrary alignment vector z α and given that Since the MDS property is satisfied (i.e., we can recover from a and r i ), B i is invertible, and the repair vector exists. The same applies for v α0 (with c b = A 0 a + B 0 b) and v βi . The role of a and b are reversed for sub-blocks to be sent to the second device. 3. Transfer (Collect). The sub-blocks prepared are sent and the first (resp. second) spare device stores them temporarily as c a = (v α1 r 1 , . . . , v αd r d ) t (resp. c b ) for further processing during steps 4 and 6. 4. Prepare (Coordinate). Using what has been received in step 3, the second spare device prepares a sub-block v α0 c b = w α0 a+z α b to be send to the first spare device. The interfering information about b is aligned as in sub-blocks prepared during step 2. Again, the role a and b are reversed for the sub-block to be sent from the first to the second spare device. 5. Transfer (Coordinate). The sub-blocks prepared are sent and the first (resp. second) spare devices adds them to blocks received in step 3 thus storing (c a |v α0 c b ) t (resp. (c b |v β0 c a ) t ). 6. Recover and Store. The d + 1 sub-blocks (c a |v α0 c b ) t = (w α1 a + z α b, . . . , v αd a + z α b, w α0 a + z α b) t allow recovering both the interfering information received wb (but not the individual values of b i ), and all the desired information a = (a 1 . . . a d ) t (i.e., the individual values of all sub-block a i ) : the received sub-blocks define d + 1 equations over d + 1 unknowns (z α b, a 1 , . . . , a d ). The lost sub-blocks are thus restored. The second spare device performs a similar processing with the role of a and b reversed. We now apply this repair method to the code we define, as shown on Figure 4. In order to repair the two systematic devices, during the collecting step, the i-th redundancy device sends (ω −(i mod α) , . . . , ω −(i+α−1 mod α) )r i to the first device being repaired and (1 . . . 1)r i to the second device being repaired. The vectors v αi (resp. v βi ) are chosen so that z α = σ (resp. z β = σ) with σ = (1 . . . 1). Let us note c a (respectively c b ) the vector of all d symbols received by the systematic devices repairing a (respectively b).
At the end of these two steps, the first device has received α + 1 equations. Let us note µ = 1 + · · · + 1 Since all the interfering information about b i is aligned, it can be written as  As a consequence, it consists of a system of α + 1 independent equations and α + 1 unknowns (a i s and σb). As a result, the α unknowns a i can be recovered. The second device has received something similar with the roles a and b exchanged.
This repair process also applies to the repair of redundancy devices. Indeed, during the first step, a change of variables is performed to transform the code C into a code C so that the two redundancy devices (or one redundancy and one systematic device) to be repaired in C become two systematic devices in C . Such a code is guaranteed to exist since the original code is MDS [10]. When repairing the 2 nd and 3 rd devices or the 3 rd and 4 th devices, the equivalent codes are shown in Figure 6.
This repair method applied to a code n = d + t, k = 2, d > k, t = 2 (n = 5 and d = 3 on Figure 4) naturally extends to other cases such as codes n > d + t, k = 2, d > k, t = 2.
  (b) devices 3 and 4 Figure 6. After a change of variable, any two repairs boil down to the repair of two systematics devices. The figure shows the system after a change of variable for the failure of one systematic device and one redundancy device (a) or the failure of two redundancy devices (b). As a consequence, we can limit our studies to the repair of two systematic devices.

C. Repairing one device
Finally, repairing one single device is an easier problem, and interference alignment has been used in several codes [10], [11]. However, we need to show that the code construction we present, which support t = 2, also supports t = 1 to get exact scalar adaptive regenerating codes. We can apply the same repair method as for repairing two devices except that there is no coordination step and the other systematic device sends directly z α b = σb during the collecting step. As a result, after the collection step, the failed device has received α + 1 equations. Since all the interfering information about b i is aligned, it can be written as  As a consequence, it consists of a system of α + 1 independent equations and α + 1 unknowns (a i s and σb). As a result, the α unknowns a i can be recovered.
Since the code we present has the MDS property and supports both repairs of single failures (t = 1) and repairs of two failures (t = 2), it implies that it is possible to design exact scalar MSCR codes and exact scalar adaptive regenerating codes, thus leading to Theorems 1 and 2.

IV. IMPOSSIBILITY OF INDEPENDENT INTERFERENCE
ALIGNMENT FOR EXACT MSCR WHEN k ≥ 3 In this section, we examine whether the previous scheme, inspired by the repair of single failures [10], [11], can be applied to multiple failures when k ≥ 3.
When repairing a single failed systematic 5 block a, the information about the k − 1 other systematic blocks must be aligned, as shown in [10]. In particular, it is required that blocks are aligned independently. Indeed, if we consider that the systematic devices send vectors v β b, v γ c. . . , and that the i-th redundancy device sends v αi a+v βi b+v γi c . . . , to the device repairing a, then it must be that, for all i, colspan (v βi ) = colspan (v β ), colspan (v γi ) = colspan (v γ ) . . . (i.e., systematic blocks are considered independently and all the information about each interfering block received at the device performing the repair span only one dimension).
We show that under this requirement, exact repair is not possible if k ≥ 3. We give a first proof, and explain the meaning of this impossibility on the information flow graph [2], [3].
Theorem 3. When requiring interference alignment to be applied independently on all devices, it is not possible to repair exactly MSCR codes with k ≥ 3 and t ≥ 2 in the scalar case (i.e., M = k(d − k + t) such that each device stores only d − k + t sub-blocks of size β = 1).
Proof: Since any MDS code C can be turned into a equivalent systematic code C (as explained in [10]), we base our proof on Lemma 5. Indeed, if it was possible to repair exactly MSCR codes with k ≥ 3 and t ≥ 2, it would be possible to build systematic MSCR codes that can be repaired exactly.
Corollary 4. When requiring interference alignment to be applied independently on all devices, it is not possible to repair exactly adaptive regenerating codes with k ≥ 3 in the scalar case (i.e., M = k(d − k + t) such that each device stores only d − k + t sub-blocks of size β = 1).
Proof: Since the repair of adaptive regenerating codes with k ≥ 3 and t ≥ 2 is very similar to the repair of of MSCR codes, the impossibility result also applies to adaptive regenerating codes. In particular, exact MSCR codes could be derived from exact adaptive regenerating codes by fixing values of d and t if such adaptive regenerating codes existed.
Lemma 5. When requiring interference alignment to be applied independently on all devices, it is not possible to repair exactly systematic MSCR codes with k ≥ 3 and t ≥ 2 in the scalar case (i.e., M = k(d − k + t) such that each device stores only d − k + t sub-blocks of size β = 1).
Proof: Let us consider a code with k ≥ 3, t ≥ 2, d > k , n ≥ d + t and α = d − k + t. Let us assume that we want independent interference alignment (i.e., each interfering block spans only a sub-space of dimension 1).
The k first devices store systematic blocks as vectors a = (a i ) 1≤i≤α , b = (b i ) 1≤i≤α , c = (c i ) 1≤i≤α . . . The n − k remaining devices store redundancy blocks as r j = A 1 a + B 1 b + C 1 c + . . . . Thus leading to a set-up similar to the one depicted on Figure 7.
? ? Figure 7. Impossibility of achieving exact repair of the systematic part of an MSCR code (k ≥ 3, d > k and t ≥ 2) We are going to proof, by contradiction, that exact repairs of systematic codes in the scalar case (i.e., β = 1) are not achievable when k ≥ 3 and t ≥ 2. For the sake of clarity, our proof will describe the case of t = 2, k = 3 and d = 4 but it naturally extends to any larger values.
Assume that it is possible to repair exactly. Hence, it is possible to repair the simultaneous failure of devices storing a and b. We consider this case and examine how exact repairs constraint the system.
For each device being repaired, all live devices project what they store onto a single vector and send this vector to the said device being repaired. Then, the devices being repaired coordinate by exchanging a single vector (a projection of what they have received so far). Hence, the device repairing a receives, at the end of both the collecting step and the coordination step:  To be able to recover a, we must be able to decode the d − k + t = 3 desired unknows of a out of the d + t − 1 = 5 equations containing a total of k(d − k + t) = 9 unknowns. Hence, when aligning independently we must have, and, Similarly, to be able to recover b, we must have, and, Let us consider the choice of vectors v γ , v αi , v βi and of matrices C i that allows exact repairs (i.e., such that constraints on ranks are satisfied) with coordination (i.e., k ≥ 3 and t ≥ 2): • All v αi C i must be collinear according to (2). • All v βi C i must be collinear too according to (3). • During the coordination step, what is sent by the device repairing a will necessarily be collinear to v αi C i (i.e., what is stored) and to vector v γ . Let us name this vector, which is colinear to v γ , z C . According to (3), z C , and hence v γ must be colinear to all v βi C i . Hence, we have: and v βi = µ i v γ C −1 i . Note that the matrix C i is invertible to guarantee the MDS property.
As a result, for all i ∈ {1 . . . d}, vectors v αi and v βi are Let us consider the choice of matrices for B i that allows exact repairs on the device repairing a. According to (2), we must have rank (B 1 v α1 , . . . , B d v α d ) t = 1, which is equivalent to: Combining (4) and (5), we can deduce that As a result, rank (B 1 v β1 , . . . , B d v β d ) t = 1 which is in contradiction with the hypothesis (3), that b can be repaired too (i.e., rank ( Hence, the exact repair of two failed devices when k > 3 is impossible. A rather similar proof can be performed assuming that c is being recovered too (t = k). In this case, the vector about c being sent to the devices repairing a and b during the coordination step needs to be colinear too. Thus leading to the same conclusion that the system is over constrained.
The proof naturally extends to any higher value of k and t. Hence, repairing exactly with d > k and t > 2 is impossible in the case of scalar codes (i.e., β = 1) based on independent interference alignment.
This impossibility means that at some point, the amounts of information that goes through the information flow graph [2], [3] is too low. Indeed, to ensure that the file is kept over time, all cuts between the source S and any data collector DC in a graph representing the transfer of data between devices during repairs must be greater than or equal to M [3]. However, if we consider the graph of Figure 8 and force the device storing c to send the same β bits of information (by requiring alignment of the information) to both the device storing a and the device storing b, then the cut shown on the graph of Figure 8 has an insufficient capacity of 8β < M.  Figure 8. If the system is constrained so that the third (or any additional) interfering device sends the same information to all devices because of alignment constraints, the flow that can go through the network is no longer equal to the file size M. In the example of the Figure, where M = 9β and α = 3β, the capacity of the cut shown is only α + 5β = 8β < M. As a result, the amounts of information that go through the network are not sufficient.
Interference alignment aims at encoding transmitted data such that all interferences at the receiver (i.e., undesired signals) are perfectly aligned and do not inhibit the reception of the desired signal. In the context of wireless, the channel matrices defining the transmission are imposed by nature and encoding matrices are carefully chosen to achieve interference alignment. When considering regenerating codes for single failures, both the channel matrices and the encoding matrix can be chosen, but it is required that one single encoding matrix allows for interference alignment at multiple receivers, each receiver acquiring a different signal. Yet, this allows a wide set of parameters to be considered. However, with coordinated regenerating codes relying on independent interference alignment, where at least two devices need to coordinated, any undesired signal from any third device must be aligned in the same way on the first and second device that coordinate. As we have just shown, this over-constrains the system thus exact repairs using independent interference alignment are not possible.
V. RELATED WORK Figure 9 gives an overview of results related to the construction of exact regenerating codes. Green nodes in the tree corresponds to achievability results while red nodes indicate that it has been shown that it is not possible to build codes for the specified parameters. The blue node correspond to an impossibility in some cases. Two main classes of codes exist, namely scalar and vector codes. Scalar codes rely on indivisible sub-blocks of size β = 1 as shown on Figure 1b. Yet, scalar codes are not always sufficient as explained hereafter. Hence vector codes, relying on sub-packetization, have been defined. In these codes, manipulated sub-blocks are smaller than the smallest amount of information to be transmitted (i.e., sub-blocks are of size β r such that to r indivisible sub-blocks are transmitted when sending β = r) as shown on Figure 1c where β = 2.
Among all possible regenerating codes, most of the studies have focused on the minimum storage point. For MSR codes that are able to repair single failures (t = 1), studies have heavily relied on interference alignment, first applied to k = 2 in [13]. The best known scalar codes either use interference alignment [11] to allow d ≥ 2k − 1, or use the product matrix framework [6] to allow d ≥ 2k − 2. However, scalar codes cannot be used to achieve d < 2k − 3 as shown in [10].
To circumvent this impossibility of constructing scalar MSR codes when d < 2k − 3, it has been proposed to rely on vector codes (i.e., β > 1). Vector codes supporting exact repair can be built for any values n, k, d when β → ∞ [7], [8]. However, these constructions require infinite sub-packetization and, hence, are not practical. Recent works [17], [18] have shown that finite sub-packetization β = (n − k) k is sufficient to perform exact repair of the systematic devices leading to practical codes. The repair of all devices is possible when d = n − 1, n = k + 2 as shown in [14]. As a result, the exact repair of all devices with vector MSR codes is not fully solved.
For the case of multiple failures t > 1, only scalar MSCR codes (β = 1) have been considered. Previous work [5] only  Figure 9. Current state of art results for exact repair codes. It compiles the most recent code constructions and impossibility results. Most codes presented here achieve exact repair for both the systematic and the redundancy part. The contributions of this paper concern scalar MSCR codes for multiple repairs (i.e., t > 1, β = 1 and d > k) and are surrounded by the black box.
considered the degenerated case of d = k where the costs of coordinated/cooperative regenerating codes is equivalent to the costs of erasure correcting codes with lazy repairs. In this work, where α = t, the repair boils down to repairing in parallel t independent erasure correcting codes (i.e., no network coding is needed). The work we present in this paper is the first to consider a non-degenerated case d > k and to apply interference alignment when multiple failures are repaired simultaneously leading to the codes we define in Section III, which are restricted to k = 2. Furthermore, in Section IV, we show that independant interference alignment with scalar codes is not sufficient for building exact MSCR codes when k ≥ 3.
With respect to the MBR point, the best known construction [6] are scalar codes based on the product matrix framework and allow the repair for any value of n, k, d. Some interesting alternative codes [15], [19] allow repair by transfer (i.e., without performing any linear operation) and rely on fractional repetition codes.
When multiple failures are repaired simultaneously, the only MBCR codes again consider the case of d = k and map to repairing t independant erasure correcting codes [12]. The existence of MBCR codes when d > k remains an open question.
Finally, regenerating codes [1], [2] can be extended into adaptive codes [3], [20] that support dynamic systems. The first supports repairing multiple failures optimally and has a constant β as long as n = d + t (i.e., as long as the total system size n including both live devices and failed devices being repaired remains constant) that makes practical implementation easier [21]. These codes are highly related to minimum storage codes. In particular, the existence (resp. nonexistence) of exact adaptive regenerating codes is strongly tied to the existence (resp. non-existence) of exact MSCR codes. In particular, our exact MSCR codes of Section III are also adaptive regenerating codes, and the impossibility shown in Section IV also applies to exact adaptive regenerating codes.

VI. CONCLUSION
In this paper, we applied independent interference alignment to minimum storage coordinated regenerating codes (MSCR) and show that this technique allows exact repair if and only if k = 2. Our results also apply to adaptive regenerating codes thus providing an interesting solution for the implementation of practical systems when k = 2.
To overcome the impossibility shown in this paper, several tracks can be considered: (i) considering a technique that does not align the interferences independently, (ii) building vector codes (i.e., relying on sub-packetization with β > 1 by opposition to scalar codes β = 1 considered in this paper as done in [7], [8], [17], [18]), or (iii) building minimum bandwidth coordinated regenerating codes (MBCR) (for single failure, codes exist for all parameters [6]). Finally, the related question of achievable limits for high rate exact MSCR when relying on scalar codes remains open.