Cooperative Local Repair in Distributed Storage
Abstract
Erasurecorrecting codes, that support local repair of codeword symbols, have attracted substantial attention recently for their application in distributed storage systems. This paper investigates a generalization of the usual locally repairable codes. In particular, this paper studies a class of codes with the following property: any small set of codeword symbols can be reconstructed (repaired) from a small number of other symbols. This is referred to as cooperative local repair. The main contribution of this paper is bounds on the tradeoff of the minimum distance and the dimension of such codes, as well as explicit constructions of families of codes that enable cooperative local repair. Some other results regarding cooperative local repair are also presented, including an analysis for the wellknown Hadamard/Simplex codes.
I Introduction
In this paper we explore a new class of codes that enable efficient recovery from the failure of multiple code symbols. In particular, we study codes with cooperative locality which allow for any failed code symbols to be recovered by contacting at most other intact code symbols. Our study of such codes is motivated by their application in distributed storage systems a.k.a. cloud storage, where information is stored over a network of storage nodes (disks). In order to protect the stored information against inevitable node (disk) failures, a distributed storage system encodes the information using an erasurecorrecting code. The code symbols from the obtained codeword are then stored on the nodes in the system. Each node stores one code symbol from the codeword.
The task of recovering the code symbols stored on failed nodes with the help of the code symbols stored on intact nodes is referred to as code repair or node repair [1]. An erasurecorrecting code with an efficient code repair process helps quickly restore the state after node failures. This consequently enables seamless operation of the system for a long time period. Recently, multiple classes of erasurecorrecting codes have been proposed that optimize the code repair process with respect to various performance metrics. In particular, the codes that minimize repairbandwidth, i.e., the number of bits communicated during repair of a single node, are studied in [1, 2, 3, 4] and references therein. The codes that enable small diskI/O during the repair process are studied in [5, 3]. Another family of erasure codes that focus on small locality, i.e., enabling repair of a single failed code symbol by contacting a small number of other code symbols, are presented in [6, 7, 8, 9, 10, 11].
A code is said to have allsymbol locality if every code symbol is a function of at most other code symbols. This ensures local repair of each code symbol by contacting at most other code symbols. In this paper we generalize the notion of codes with allsymbol locality to codes with cooperative locality: any set of code symbols are functions of at most other code symbols. This allows for cooperative local repair of code symbols, where any group of failed code symbols is repaired by contacting at most other code symbols.
The ability to perform code repairs involving more than one failure is a desirable feature in most of the distributed storage systems that can experience multiple simultaneous failures [12]. Moreover, this property also allows for deliberately delaying code repairs when system resources need to be freed to support other system objectives, e.g., queries (accesses) to the stored information by clients. Here, we note that the approach of cooperative code repair has been previously explored in the context of repairbandwidth efficient codes in [13, 14] and references therein.
In this paper we address two important issues regarding codes with cooperative locality: 1) obtaining tradeoffs among minimum distance, dimension (rate), and locality parameters for such code; and 2) presenting explicit constructions for codes with cooperative locality that are close to the obtained tradeoffs. Towards designing codes with cooperative locality, we mainly focus on codes with maximum possible rate. We construct a code with cooperative locality that has rate at least . This code construction is based on the regular bipartite graphs with girth at least . In the light of an upper bound on the rate of a code with cooperative locality that we show later, this construction provides codes that are very close to being optimal. Here, we also note that there are explicit constructions for the regular bipartite graphs with large girth [15]. Thus, one can obtain high (almost optimal) rate codes with cooperative locality for distributed storage systems. Note that, a minimum distance is not guaranteed in this construction. We also show that the codes based on expander graphs enable cooperative local repairs while maintaining both high rate and good minimum distance.
Given a large number of parity constraints with low weights, expander graph based codes are natural candidates for codes to enable locality. However, these codes are overkill when one is interested in code repair of single failed symbol and codes with significantly better rate vs. distance tradeoff can be obtained [6, 16, 9, 11]. But as we aim to recover from multiple failures in a local manner, these codes become an attractive option.
Construction 
Cooperative locality 
Rate 
Minimum distance 

Partition code (Sec. IVA)  
Product code (Sec. IVB)  
Concatenated code (Sec. V)  
Regular bipartite graph based code (Sec. VIA) 

Unbalanced bipartite expander graph based code (Sec. VIB1) 

Double cover of regular expander graph based code (Sec. VIB2) 

Hadamard code (Sec. VII) 
,

Ia Contributions and organization
In Section II, we first present a formal definition of codes with cooperative locality and highlight the connections between the notion of cooperative locality as defined in this paper and various other contemporary notions from distributed storage literature [17, 11, 18, 19, 20, 16, 9, 10] that aim to generalize locally repairable codes (LRCs) [6, 7]. In Section IIA, we comment on the cooperative locality parameters of the codes with multiple small sized disjoint repair groups for each code symbol [17]. In Section IIB, we highlight both the differences and similarities between the codes with cooperative locality and the codes with locality [16].
In Section III, we obtain an upper bound on the minimum distance of a code with cooperative locality which encodes information symbols to symbols long codewords. As a special case of this result, we then obtain a bound on the best possible rate for a code with cooperative locality with no further minimum distance requirement. We address the issue of providing explicit constructions for codes with cooperative locality in Sections IV, VIA and VIB.
In Section IV, we present two simple constructions for the codes that have cooperative locality and comment on their rates with respect to the bound obtained in Section III. In Section VIA, we consider the codes based on regular bipartite graphs with large girth (girth = length of the smallest cycle). In particular, we show that a code based on regular bipartite graph with girth allows for cooperative local repair of failed code symbols. We further study cooperative locality of the codes based on expander graphs in Section VIB. We comment on the conditions in terms of expansion ratio or second eigenvalue that the underlying expander graph needs to satisfy for the code to enable cooperative repair of a certain number of erasures. Table I summarizes the rates and distances obtained by various code constructions considered in this paper.
Certain families of classical algebraic codes may possess local repair property. In Section VII, we study punctured Hadamard codes (a.k.a. Simplex codes) in the context of cooperative local repair. We show that a punctured Hadamard code with symbols long codewords has cooperative locality for any . We conclude this paper in Section VIII with some directions for future work.
A short note on notation: we use bold lower case letters to denote vectors. For an integer , denotes the set . For a code , we use and to denote its rate and minimum distance, respectively.
IB Related work
The concept of codes with small locality for distributed storage system is introduced in [8, 6, 21]. In [6], Gopalan et al. study the rate vs. distance tradeoff for linear codes with small locality or locally repairable codes^{1}^{1}1Throughout this paper, we use both “codes with small locality” and “locally repairable codes” to refer to the codes that enable local repair of a single failed code symbol.. The similar tradeoffs under more general definitions of locally repairable codes and constructions of the codes attaining these tradeoffs are studied in [7, 16, 9, 10, 22, 23, 11] and references therein.
In [24], Prakash et al. consider codes that allow for local repair of multiple code symbols. In particular, they focus on codes that can correct two erasures by utilizing two parity checks of weights at most . Prakash et al. derive the rate vs. distance tradeoff for such code and (for large enough field size) show the existence of the codes that attain the tradeoff. We note that the definition of cooperative locality considered in this paper is more general than that studied in [24]. Moreover, we do not restrict ourselves to only two erasures. In Section VIA2, we show that the codes based on regular bipartite graphs with high girth are ratewise (almost) optimal under the natural generalization of [24] to more than two erasures.
Recently, the codes that enables multiple ways to locally repair a code symbols have received attention. In [17, 11, 18], the codes that enable multiple disjoint repair groups for every code symbol are considered. The codes that provide multiple disjoint repair group for only information symbols are studied in [20, 19]. In Section IIA, we comment on the implication of this line of work for the issue of cooperative locality.
Ii Codes with cooperative locality
Definition 1.
A ary code with length and dimension is called an code. We define an code to be a code with cooperative locality if for each with , we have a set such that

,

For any codeword , the code symbols are functions of the code symbols .
Note that Definition 1 ensures that any code symbols can be cooperatively repaired from at most other code symbols. This generalizes the notion of codes with allsymbol locality [6, 7, 8], where locality is defined with respect to one code symbol, i.e., .
Remark 1.
Iia Cooperative locality from codes with multiple disjoint local repair groups for code symbols
In [17, 11, 18], codes with multiple disjoint local repair groups for all code symbols are studied. These codes allow for multiple ways to recover a particular code symbol by contacting disjoint sets of small number of other code symbols. In particular, the work in [17, 11, 18] study codes with at least disjoint local repair groups, each comprising of at most other code symbols. We claim, according to our definition, these codes also have cooperative locality for each . Without loss of generality, we establish this for , i.e., we argue that a code with disjoint repairs groups (each of size at most ) has cooperative locality.
Consider a set of code symbols in failure. For any of these failed code symbols, each symbol can have at least one failed code symbol in at most of its disjoint repair groups. This implies that the code symbol under consideration has at least one of its local repair groups free of any failures. Thus, the code symbol can be repaired with the help of one of its intact local repair groups. This leave us with code symbols in failure (erasure). Now, for another code symbol in failure, we can have at most of its disjoint local repair groups with at least one failed code symbol. This leaves at least of its disjoint local groups intact; therefore, this code symbol can be repaired with the help of one of its intact local repair groups. Following the similar argument, we can see that all of the failed code symbols can be repaired in a code with disjoint repair groups for all code symbols. In the worst case, we contact at most code symbols to repair all of the failures. This establishes the cooperative locality for the codes under consideration.
Similarly the codes with availability [19, 20], which enable multiple disjoint repair groups only for information (systematic) symbols in a codeword, can allow for cooperative local repair for certain ranges of system parameters. In particular, [20, Construction I] can give codes with cooperative locality and rate .
Remark 2.
Here, we would like to note that the definition of the codes with cooperative locality (Definition 1) is more general. In particular, we show in Section IVA, Section V and Section VIA that it is possible to have codes with cooperative locality that do not have at least disjoint local repair groups for all code symbols (or information symbols).
IiB Comparison with the codes with locality [9, 10]
In [16], Prakash et al. propose to study codes with locality, a generalization that enforces additional requirements which the local repair groups of an LRC need to satisfy. In particular, a code is said to have locality if there is a set of codes obtained by puncturing the code , for some index set , such that the following three requirements hold: 1) For each , the support of is no more than , 2) for each , the minimum distance of is larger than or equal to , and 3) each code symbol is contained in the support of at least one of the punctured codes , . The rate vs. distance tradeoffs for the codes with locality and the constructions attaining these tradeoffs are presented in [9, 10].
Note that a code with locality ensures repair of any failures within each punctured code. Here, we would like to highlight that the notion of cooperative locality is different from that of locality. In particular, codes with cooperative locality are not required to meet the requirement 2) in the aforementioned definition of the codes with locality. As a result, there are families of codes which satisfy the requirements of cooperative locality, but that do not meet the definition of the codes with locality. We illustrate this with the help of the following example.
Let be a code which encodes message symbols to a symbols long codeword
We note that the code is nothing but a Simplex code which we study in Sec. VII. It follows from the analysis presented in Sec. VII that this code has cooperative locality, i.e., any set of failed code symbols can be recovered by contacting other code symbols. Let’s assume that the code symbols and are in failure. In this case we can recover both the failed code symbols from the set of code symbols . In other words form a punctured code of the original code at indices. However, this punctured code does not have minimum distance at least . This can easily be observed from the fact that the punctured subcode does not allow the repair of code symbols and from the remaining set of code symbols . Moreover, there is no punctured codes of the original code at at most indices which has minimum distance at least . Therefore, is an example of a code with cooperative locality which does not have locality as defined in [16].
This also shows that the definition of cooperative locality is not a strengthening of the definition of locality. Hence, one cannot directly invoke the impossibility results for the codes with locality to obtain impossibility results for the codes with cooperative locality. However, as far as the achievability is concerned, a construction for a code with locality gives a construction with cooperative locality as explained in Sec. IV.
Iii Rate vs. Distance Tradeoff for Codes with cooperative locality
In this section, for given and , we present a tradeoff between the rate and the minimum distance of a code with cooperative locality (cf. Definition 1). We employ the general proof technique introduced in [6, 22, 23] to obtain the following result.
Theorem 1.
Let be an code (linear, or nonlinear) over the finite field with cooperative locality. Then, the minimum distance of satisfies
(2) 
Furthermore, when we have , the minimum distance of satisfies the following.
(3) 
Proof.
The proof involves construction of a subcode such that all but a small number of coordinates in every codeword of are fixed. The coordinates of the codewords in are fixed in an iterative manner as follows. In each iteration, we consider a set of coordinates which have not been fixed so far. Then we pick the set of other coordinates such that the code symbols associated with these coordinates allow us to repair the code symbols associated with the coordinates under consideration. The current iteration ends with fixing these coordinates to some specific values. Note that some of the coordinates may have been fixed in the previous iterations. We describe the iterative construction of the subcode in Fig. 1. Given the subcode , we have
(4) 
Given , one can obtain a code with by removing fixed coordinates from all the codeword in . This implies that , which along with (4) give us the following.
(5) 
We refer the reader to Appendix A for the complete proof. ∎
Remark 3.
It is possible to obtain a bound on the minimum distance of codes with cooperative locality that depends on the alphabet size, in the spirit of [22]. Indeed, a more general version of Theorem 1 will give,
where is the maximum size of a ary errorcorrecting code of length and distance . The proof of this bound is straightforward.
Note that an code with cooperative locality has its minimum distance at least as it can recover from the erasure of any code symbols (cf. Definition 1). Combining this observation with Theorem 1, we obtain the following result.
Corollary 1.
The rate of an code with cooperative locality is bounded as
(6) 
Furthermore, for case when we have , the rate of an code with cooperative locality satisfies
(7) 
Proof.
Remark 4.
Here, we note that the assumption is a natural assumption as it always holds for linear codes with coopreative locality and dimension at least , i.e., . Note that the additional term that we have for the case when vanishes as becomes large as compared to .
Iv Naive constructions of codes with cooperative locality
In this section we address the issue of constructing high rate codes that have cooperative locality. In particular, we describe two simple constructions that ensure cooperative local repair for the failure of any code symbols: 1) Partition code and 2) Product code. In Partition code, we partition the information symbols in groups of symbol and encode each group with an MDS code (cf. Section IVA). On the other hand, a product code is obtained by arranging information symbols in an dimensional array and then introducing parity symbols along different dimensions of the array (cf. Section IVB).
Iva Partition Code
For the ease of exposition, we assume that and . Given information symbol over , a Partition code encodes these symbols into symbols long codewords as follows:

Partition information symbols into groups of size each.

Encode the symbols in each of the groups using an MDS code over . We refer to the code symbols obtained by encoding information symbols in the th group as th local group.
As it is clear from the construction, Partition code has rate . Moreover, a code symbol can be recovered from any other code symbols from its local group. In the worst case, when failed code symbols belong to distinct local groups, we can recover all symbols from code symbols, downloading symbols from each of the local groups containing one failed code symbol.
Remark 5.
Note that the Partition codes presented here are special cases of codes with locality as studied in [10, 9] (cf. Sec. IIB). The partition codes as described above only aim at maximizing the rate of the code. If we are also interested in achieving large minimum distance, then we can take strictly greater than and attain the following relationship between the minimum distance and the code dimension [9]
(10) 
In the above construction of the Partition codes we use an MDS code to encode disjoint groups of message symbols. Note that the rate of this MDS code governs the rate of the overall code. One can potentially use some other code of minimum distance at least to encode disjoint groups of message symbols. Now, we use , to denote the number of symbols that needs to be contacted to repair erasure in one local group. For the case when an MDS code is used, we have for . Let denote the upper concave envelope of on the interval . Assume that we have disjoint local groups, then a pattern of erasures can be represented by a vector . Here, denotes the number of erasures within the th local group. Note that we have .
For a given local code , one needs to access number of intact code symbols to repair the erasure pattern . Now, we use concavity of , the fact that for , and Jensen’s inequality to obtain the following.
(11) 
Since the rate of the Partition code is agnostic to the number of local groups, we can use the value of which can support message symbols and minimizes the R.H.S. of (11). This approach optimizes the value of for a given choice of and .
Example 1.
It is possible to achieve better locality parameters in Partition code than just to use copies of MDS codes. Consider a Partition code with two blocks, each being a punctured Hadamard [7,3,4] code. From Theorem 4, we know that , for for these Hadamard codes. Hence, we have an code with cooperative locality.
On the other hand, consider a Partition code with two blocks of MDS codes. For this code, we may need to access up to symbols to repair even two symbols. Indeed, the overall code has cooperative locality.
IvB Product Code
Product codes are a well known construction of codes in the coding theory literature. Given information symbols and , we first arrange information symbols in an dimensional array with index of each dimension of the array ranging in the set . These information symbols are then encoded to obtain an symbols long code word. In the following we describe the encoding process for dimensional array. The generalization of the encoding process for higher dimensions is straightforward.

Arrange information symbols in an array.

For each row of the array, add a parity symbol by summing all symbols in the row and append these symbols to their respective rows.

For each of the columns of the updated array, add a parity by summing all symbols in the column.
Remark 6.
An dimensional product code enables disjoint repair groups for all code symbols. For example, every code symbol in a dimensional product code has two disjoint repair groups, associated with its row and column, respectively. Therefore, cooperative locality of product codes follows from the discussion in Section IIA. We note that product codes along with their minimum distance have been previously been considered in [11, 19] in the context of codes with small locality.
We now compare the rate of Partition code and Product code with the bound in (7). For any , we have
(12) 
Note that (12) follows from the fact that
Therefore, Partition code approach provides cooperative locality with a better rate. However, for all system parameters, the rate of Partition code is smaller than the known bound (7), i.e.,
Here, we would like to note that the difference between the rate achieved by the Partition code and the bound in (7) gets smaller as the parameter becomes large as compared to the parameter . It is an interesting problem to either tighten the bound in (7) or present a construction for codes with cooperative locality which have higher rate than that of Partition code. In the next two sections we present two approaches to achieve this goal.
V Concatenated Codes with cooperative locality
Here, we describe a family of concatenated codes with cooperative locality. This construction employs an MDS code and a code with small locality as inner and outer codes, respectively. In particular, we employ an MDS code over and an code with cooperative locality over as inner and outer codes, respectively. Let be the concatenated code. We know that
(13) 
Before we describe the concatenated codes with cooperative locality for general , let’s consider a few examples for small values of .
Va When
Let us take an MDS code over as the inner code. This code can repair any one failed code symbol by contacting the remaining code symbols. For outer code, we employ a code with cooperative locality over . This can repair any one super symbol (which consists of symbols of ) by contacting symbols over , i.e., symbols over . (Note that in order to repair a super symbol, we can obtain the value of required super symbols by contacting symbols over from each of their corresponding codewords of the inner code.)
If erasures lie in the inner codewords of different super symbols, then we can repair each of these erasures by contacting other code symbols. This amounts to using symbols over . If at least erasures belong to the inner codeword of a super symbol, we can employ cooperative locality of the outer code to repair the corresponding super symbol. In the worst case, we contact symbols over , when erasures belong to one super symbol and the third erasure belongs to another super symbol. Since we want
we have . Taking , we can get the concatenated code with rate
Moreover, this code has minimum distance at least . Now, we compare the rate of the obtained concatenated code with that of the Partition code described in Section IVA, which has rate .
(14) 
Hence, for all , the concatenated codes have a higher rate than the Partition codes.
VB When
Here, we focus on obtaining the codes with cooperative locality. We use an MDS code over as the inner code. This code can correct erasures within an inner codeword associated with a super symbol. In order to repair a super symbol, we employ a code with cooperative locality over as an outer code. It can be easily verified that (for suitable value of ) the concatenated code obtained by this approach allows for the recovery of erasures by contacting at most symbols over . In particular, when the inner codeword associated with one super symbol encounter erasures and the inner codeword associated with another super symbol encounter erasure, we contact at most symbols over . Since we need to satisfy
we have . Working with , one can obtain a code with cooperative locality and rate
Moreover, the concatenated codes obtained in this manner have minimum distance at leat . We obtain better rate as compared to that of the Partition codes (cf. Section IVA), iff
(15) 
VC General values of
Here, in addition to , we assume that is even^{2}^{2}2This assumption is just for the ease of exposition and a similar construction for odd can also be proposed.. For , We now take an MDS code over as the inner code. For outer code, we employ a code over that can locally recover failed (erased) super symbols. Note that there exist such codes with rate (cf. Section IVA and Section IIA)
where denotes the number of super symbols needed for the local repair of super symbol. In our definition, these codes have cooperative locality for all .
Now, consider the case where all erasures lie in the inner codewords corresponding to different super symbols, we can repair all erasures by contacting code symbols over . For the case where super symbols are in erasure, in the worst case, we have erasures in the inner codewords corresponding to distinct super symbols and erasure in the inner codewords associated with different super symbols. In order to repair these erasures, we contact
symbols over . Since we need to satisfy,
we get . Therefore, the rate of the concatenated code we get is
(16) 
Note that the concatenated code obtained in this section has minimum distance at least .
Vi Cooperative locally repairable codes using codes on graphs
The concatenated codes described in Section V enable cooperative locality with better rate and minimum distance as compared to those of Partition codes. However, the improvements obtained by concatenated code approach are small and limited to the bounded values of the parameter . In this section, we present various graphs based codes that improve upon the previously described approaches for a large range of system parameters.
Via Bipartite graphs with large girth
The girth of a graph is the number of vertices in the shortest cycle of the graph. In this section, we explore a particular class of codes based on bipartite graphs with high girth. In this construction, the code symbols are associated with the edges of a bipartite graph and both the left and right vertices in the the bipartite graph enforces the constraints on the code symbols associated with the edges incident on these vertices. The analysis of the cooperative locality of the codes obtained in this manner is based on the fact that the underlying bipartite graph has high girth.
Let be a bipartite graph where and denote the set of left and right vertices, respectively. In particular, we work with the bipartite graphs that are biregular, i.e., all the vertices from one part have the same degree. If all the left vertices and right vertices have degree and , respectively, then we refer to such a bipartite graph as a regular bipartite graph. In the case, where we have , we simply call the bipartite graph as regular bipartite graph. Given the bipartite graph , we obtain a code (over ) in the following manner:

We assign each edge in the bipartite graph with a code symbol in the codewords of . That is, .

For every (left or right) vertex in the bipartite graph, all the code symbols associated with the edges incident on the vertex satisfy a linear constraint (over ).
Before stating our general result on the cooperative locality of the codes obtained in this manner, we consider small values of . Note that any two edges in (code symbols in a codeword of ) share at most one vertex (appear together in at most one local constraint). Thus, for code symbols in erasure, it is possible to find two local constraints that contain exactly one of the two erased symbols. This allows for the repair of both the erased symbols by utilizing these two local constraints. In other words, the code has cooperative locality, where denotes the maximum degree of the underlying bipartite graph . Similarly, even in the presence of erasures, one can find at least two local constraints such that there is only one erasure among the code symbols participating in each of these constraints. Fig. 1(a) and 1(b) illustrate this fact by considering two possible patterns of erasures. Now, using these two constraints one can repair two erasures, which leaves only one erased symbol which can then be recovered with the help of any of the two local constraints it appears in. The repair of erasures involves at most other code symbols; hence, the code has cooperative locality. In order to cooperatively repair erasures in , we utilize the fact that the underlying bipartite graph has high girth.
erasures are colored in red.
Theorem 2.
Let be a regular bipartite graph with girth , then the code obtained from the construction described above has cooperative locality.
Proof.
A bipartite graph can only have cycles of even length (number of vertices or edges). Note that as we explain this before stating this theorem, the code can correct up to erasures without any assumption on the girth of the bipartite graph . Therefore, without loss of generality we can assume that the girth of the bipartite graph is at least six^{3}^{3}3Note that Theorem 2 guarantees cooperative local repair of only erasures when ., i.e., . We use induction over the number of erasures to prove the claim. For the base case we consider the case of erasures. As described in the paragraph preceding the statement of this theorem, the code can recover from erasures in a cooperative manner.
Now as an inductive hypothesis, we assume that the code can repair at most erasures in a cooperative manner and show that it is also possible to repair erasures. Towards this, we show that given erasures, it is possible to obtain a local constraint which has a single erasure among the code symbols appearing in the constraint. Finding such a constraint allow for the recovery of one erasure leaving erasures. In order to show a contradiction, we assume that no such local constraint exists. We start with a vertex say with at least of the code symbols associated with the edges incident on it in erasure. We then traverse along one of the edges out of the vertex which have their corresponding code symbols in erasure. (Note that there are at least of such edges.) Let denote the vertex that we arrive at after traversing the edge. Since has at least code symbols associated with its edges in erasure, we can now pick an edge associated with one of the erased symbol to reach another vertex which is different from . We continue this process until we can not traverse to an unexplored vertex through an edge with its associated symbol in erasure. Note that this process is bound to end in at most steps as there are only erasures. This process can end with two possibilities: 1) we have traversed through all edges associated with erased symbols or 2) all the unexplored edges from the last vertex leads to previously visited vertices. The first possibility is not feasible under our assumption as it implies that the last vertex has only single erasure associated with the edges incident on it. The second possibility leads to the existence of cycle of length at most which is infeasible as . This leads to a contradiction. Thus, it is possible to obtain a local constraint which has a single erasure among the code symbols appearing in the constraint. Now that we are remained with erasures, we can employ the inductive hypothesis to complete the proof.
As for the total number of intact code symbols contacted during the repair process, in the worst case, we may need to utilize different local constraints to recover from erasures. This amounts to contacting intact code symbols. ∎
Remark 8.
(Construction of regular bipartite graphs with large girth) The problem of constructing regular bipartite graphs with large girth has received significant attention in the past. Here, we like to point out the work presented in [25, 15] and references therein. For an odd integer and prime power , Lazebnik et al. present explicit construction for regular bipartite graphs with girth at least and number of edges [15]. Therefore, for any , one can design a code using a regular bipartite graph from [15] which ensures cooperative local repair of any erasures.
ViA1 Rate and distance of obtained from a regular bipartite graph
When is a regular bipartite graph of degree , the number of independent linear constrains on the codewords is at most . Hence the rate of the code is
Note that Theorem 2 establish that the code obtained using a regular graph with girth has cooperative locality. If we set and , then the following holds for the code with cooperative locality.
(18) 
As far as the minimum distance of a code based on a regular bipartite graph with girth is concerned, we have the following trivial bound from Theorem 2.
(19) 
One can construct a Tanner graph corresponding to the graph . The left vertices and right vertices in this Tanner graph correspond to the edges in the graph and the vertices in the graph , respectively. The Tanner graph is a biregular bipartite graph with left degree and right degree . Moreover, the girth of is . We can now use [26, Theorem 2] to conclude that
(20) 
where is the minimum distance of the smaller code associated with each vertex in the graph . For our case of , (20) does not give us anything better than (19).
Remark 9.
The relationship between stopping number, the smallest number of erasures that cannot be corrected under iterative decoding, and the girth of the Tanner graph associated with a code have been previously explored in the literature [27]. As described above, we can obtain a Tanner graph corresponding to the graph . This allows us to draw the connections between Theorem 2 and the literature on stopping number.
Remark 10.
Compared to (7), this achievability result has a loss of at most from the optimal possible rate.
ViA2 Comparison with the work in [24]
Recently, Prakash et al. study codes which allow for local repair of erasures [24]. In their model, they perform the repair of the two erasures in a successive manner, where a parity constraint of weight at most is used to repair each of the two erasures. In [24], Prakash et al. show that such codes have their rates upper bounded by .
Note that their model can be generalized to erasures, and one can consider codes that enable successive local repairs from erasures by contacting parity constraints of weight at most . The codes based on bipartite graphs with high girth, as proposed in this section, fall under this setting. Taking , their rate (cf. (18)) is at least . Since the upper bound from [24] still applies to these codes, they exhibit almost optimal rate.
ViB Expander graphs
The above analysis of the construction based on bipartite graphs fails to show a high minimum distance on top of the local repair property. However with the graphical construction it is also possible to have high distance, and hence protection against catastrophic failures. Next we show how the expansion property of graphs leads to such conclusion.
ViB1 Unbalanced bipartite expanders
Let be an unbalanced left regular bipartite graph with and left degree . We assume that the graph is an expander graph where expansion happens from left nodes to right nodes. In particular, we assume that for all such that , we have
(21) 
Here, denotes the set of right nodes that constitute the neighborhood of the nodes in the set .
We now associate a code symbol with each of the left nodes in the bipartite graph . For , let denote the neighborhood of the node . Consider a code such that for each , the code symbols associated with constitute a codeword in a shorter MDS code with length and minimum distance at least . Note that this approach of constructing codes from unbalanced expander graphs is proposed in [28, 26] and references therein.
Next, we argue that for small enough (cf. (21)), the code should be able to correct any set of at most erasures. Note that the locality parameter is dictated by the degrees of the right nodes in the graph .
Theorem 3.
Let be an unbalanced (left) expander bipartite graph as defined in (21). If we have , then the code can be locally repaired from any or less number of erasures by contacting at most code symbols.
Proof.
We prove the claim using induction on . Note that a single erasure can be repaired by using one of the local constraints the erased code symbol participates in. Now assume that at most erasures can be repaired by using local constraints defined by the graph . We now show that any set of erasures can also be repaired using local constraints.
Let with denote the set of erased code symbols. In order to repair these erasures, we start with a right node which has at most of the code symbols associated with its neighborhood in erasure. These erasures can be corrected under the local constraints satisfied by the code . We can then utilize the inductive hypothesis to complete the proof.
Note that what remains to be shown is that the desirable right node with at most associated erasures exists. Towards this, we assume that there is no such right node. In other words, this implies that the induced subgraph defined by the nodes has at least edges incident on every node in from the nodes in . Therefore, we have
(22) 
However, for , it follows from (21) that
This along with (VIB1) leads to a contradiction. Hence, in the presence of at most erasures it is possible to find the desirable right node (with at most erasures among the code symbols associated with its neighborhood).
Now the claim that follows from the fact that correcting each erasure requires contacting at least code symbols from a codeword of the shorter code . ∎
Let be such that the graph allows for expansion of all sets of size at most by a factor of at least , i.e.^{4}^{4}4As shown above, is a sufficient condition for the code obtained from the bipartite graph to be able to allow for cooperative repair of erasures.,
Proposition 1.
For the code based on the bipartite graph above and local codes of minimum distance , we have,
A proof of this fact, which is an extension of existing results (such as [28]) is provided in Appendix B. We further assume that the bipartite graph is biregular with denoting its right degree, i.e., . Moreover, let represent the shorter code of length used to define the code . Then we have,
where denotes the maximum number of intact code symbols that need to be contacted to repair erasures.
Remark 11.
Here, we note that for any constant and , it is possible to explicitly construct unbalanced expander graphs with constant degree , and expansion factor for sized subsets of left vertices [29].
ViB2 Regular expander graph
We now study the cooperative locality of the codes obtained by the double covers of regular expander graphs [28]. The analysis of the cooperative locality is based on the analysis of the decoding algorithm for these codes presented in [30]. Note that we naturally modify the decoding algorithm from [30] to perform erasure correction in a cooperative manner.
Let be a regular graph with and as the second (absolute) largest eigenvalue of its adjacency matrix^{5}^{5}5If be eigenvalues of the adjacency matrix of , then .. Given , we construct a bipartite graph with in the following manner (see Fig. 3):

Each vertex in the original graph corresponds to a left node and a right node in the graph .

For a pair of vertices , there exists an edge iff there is an edge between the vertices and in the original graph , i.e., .
The bipartite graph is referred to as the double cover of the graph . Note that the bipartite graph is regular with total edges. Moreover, the following result holds for the bipartite graph .
Lemma 1.
(Expander Mixing Lemma)[31] Let be the regular bipartite graph as described above. Then, for every and , we have