ON APPLICATIONS OF ORBIT CODES TO STORAGE

. We consider orbit codes, namely subspace codes obtained from orbits of the action of subgroups of GL n ( F q ) on m -dimensional subspaces of F nq . We discuss their applicability to design storage codes, in particular in the context of collaborative repair: we identify known storage codes that can be interpreted as orbit codes, motivate why orbit codes provide good candidates for storage codes, and translate the storage code parameters into those of the algebraic objects involved. Two simple families of storage orbit codes are given.


Introduction
Consider an (N, n) linear code C over the finite field F q , q a prime power, that is, C is an n-dimensional subspace of F N q . A codeword in C, in the context of communication, is sent over an erasure channel, which will result in an erroneous codeword, where some of its components have been erased. The code should be designed so as to permit the recovery of the codeword, assuming a given erasure pattern. The minimum Hamming distance d H of the code characterizes the erasure recovery capacity of the code, sometimes then denoted as an (N, n, d H ) code.
This scenario can be easily translated into the context of distributed storage systems. Instead of sending a codeword over an erasure channel, store the N coefficients of a codeword of C into N storage nodes. Node failures become erasures, and whether the stored encoded object can be retrieved given a failure pattern depends on d H .
There is however a fundamental difference between erasure codes for communication, and erasure codes for distributed storage: in the former case, once the altered codeword is received, it is not deteriorated anymore, while in the latter case, a storage system is meant to last over months or years, and failures continue to happen. Therefore, no matter how good a linear code is, it cannot protect data from failures, without maintenance [10]. Maintenance means that in case of node failures, it is necessary to repair the data that became unavailable, namely: codeword coefficients which are erased need to be recomputed, and stored at live nodes. This can be done using a decoding algorithm, but often, it is preferred to have more efficient ways to compute codeword coefficients, typically as a linear combination of a small number of other codeword coefficients. When several nodes jointly repair t failures, t ≥ 2, the repair process is said to be collaborative [2,13]. The metrics of interest to decide the efficacy of a storage code with respect to maintenance are typically the amount of bandwidth needed per repaired node, which is a function of data stored per node, and the number of nodes contacted per repair. The latter is often in tension with the optimal trade-off between repair bandwidth and storage overhead.
To better handle the maintenance process, it is often useful to consider an (N m, n) linear code C, with generator matrix (v 1 , . . . , v N m ) ∈ Mat n×N m (F q ), with columns v i ∈ F n×1 q , i = 1, . . . , N m (This is also an approach used in the context of array codes, see e.g. [15]). Then a data object o ∈ F 1×n q is encoded into a codeword (ov 1 , . . . , ov N m ) ∈ F 1×N m q , and the N m codeword coefficients are distributed into N storage nodes, each node storing m coefficients. This helps the maintenance process in that it allows the content of a node to be repaired with lesser communication cost than if the node content is considered as a single symbol. Each storage node is assumed to be equipped with computational power, therefore, a node storing ov i1 , . . . ov im is able to compute F q -linear combinations m j=1 α i ov ij . From this point of view, it makes sense to therefore model each storage node as storing an m-dimensional subspace of F m q with F q -basis v i1 , . . . , v im (we may assume without loss of generality that v i1 , . . . , v im are linearly independent), as explicitly suggested in [1].
With the above view point, the problem of designing storage codes then becomes that of finding N m-dimensional subspaces of F n q , which naturally brings in the Grassmannian G q (m, n), which is by definition the set of all subspaces of F n q of dimension m. The question is then how to pick subspaces appropriately for the purpose of storage. A first tentative to treat storage codes in this manner was presented in [8], using Grassmannian graphs, which yielded some interesting constructions. A systematic approach to design subspace codes for storage has been recently proposed in [12], which relies on Plücker embeddings. Subspace codes were in general studied from a group action point of view in [14], which introduced the concept of orbit codes. In this paper, motivated by the natural interpretation of storage codes in terms of subspaces and by their properties, we adopt the approach of orbit codes, and question the applicability of such codes to distributed storage, hoping to exploit group actions as a way to characterize good storage codes.
We are particularly interested in the collaborative case, where nodes involved in the repair of t failures, t ≥ 2, download data from live nodes, and exchange some of their obtained data among a subset of each others. When this subset is not proper and involves all t − 1 other nodes, it is referred to as collaborative, while partial collaboration [5] emphasizes that data is exchanged among a proper subset of strictly less than t − 1 nodes. One reason for choosing this setting is that the one failure case has been already well studied and many codes are available (see [10] and reference therein), while the scenarios of collaboration, and especially partial collaboration, have been less studied, and few constructions are known for partial collaboration [6]. We focus on two classical extreme regimes: one where the amount of repair bandwidth per repaired node is minimized, and one where the amount of storage per node is minimized.
The paper is organized as follows. In Section 2, we translate code parameters in terms of orbit codes, and give a motivating example. In Section 3, we focus on orbit codes generated by the companion matrix of a polynomial, and propose a simple family of codes, for partial collaborative repair, which minimizes the repair bandwidth. We further identify a known class of storage codes [9] as being one instance of cyclic orbit codes. In Section 4, we present another construction of orbit codes for partial collaboration, aiming this time at minimizing the storage. Though this instance of orbit codes is simple, it does achieve the optimal performance in terms of trade-off between storage and repair bandwidth. In Section 5, we compare the two constructions with known bounds: the first construction is shown to achieve the minimum repair bandwidth, but trade the corresponding optimal storage with the minimal number of nodes contacted per repair. Note that as of now, optimal families for partial collaboration at the minimum repair bandwidth case are not known. The second construction is indeed offering the minimum storage together with its corresponding minimum repair bandwidth. The number of contacted nodes per repair is large. The presented codes have the further benefit of being easily generated, as orbit codes are likely to be in general. It turns out that though the framework of orbit codes seem fairly natural to address storage codes, and some known storage codes can be interpreted as orbit codes, the dependency of the code parameters not only on the cyclic group which is acting but also on the original subspace on which the cyclic group acts complicates the study of such codes, which therefore leaves many open questions.

Storage codes from orbit codes
As above, let F q be the finite field with q elements, with q a prime power, and let G q (m, n) be the set of all subspaces of F n q of dimension m, called Grassmannian: G q (m, n) = {U subspace of F n q , dim(U) = m}. We denote by GL n (F q ) the set of n × n invertible matrices with coefficients in F q . Multiplication by elements of GL n (F q ) defines a group action from the right on G q (m, n) by since any element of GL n (F q ) maps an m-dimensional subspace to an m-dimensional subspace. In fact, as pointed out in [14], since any two m-dimensional subspaces can be mapped onto each other by an element of GL n (F q ), GL n (F q ) acts transitively on G q (m, n).
Fix U ∈ G q (m, n), let G be a subgroup of GL n (F q ), and let UG = {Ug, g ∈ G} be the orbit of U under the right action of G. We will refer to UG as an orbit code, following the terminology of [14]. If furthermore G is cyclic, we call UG a cyclic orbit code.
In order to represent an m-dimensional subspace U of the vector space F n q , we fix a basis of U, and use an m × n matrix U whose row space {vU, v ∈ F m q } is U. Orbit codes form collections of m-dimensional subspaces of F n q obtained by group action, which have been successfully used in the context of network coding [14]. This makes them potential candidates to provide codes for distributed storage. Let us see how the storage parameters are translated into parameters for an orbit code UG, assuming that an object o of length n is stored.
2.1. Code length. The number N of storage nodes is the length of the code, that is the cardinality |UG| of the orbit UG, and it is well known that where Stab G (U) = {g ∈ G, Ug = U} is a subgroup of G called the stabilizer of U. Alternatively Indeed, if g ∈ Stab G (U), then g ∈ G and g is also an element of GL n (F q ) such that Ug = U. For the reverse inclusion, similarly, if g ∈ G and Ug = U, then g ∈ Stab G (U). The following two results give a way to compute the stabilizer of U, and in turn the number of nodes over which the storage code is used. Lemma 1. Let U I be the m-dimensional subspace generated by the first m unit vectors, that is, it has U I = (I m , 0 m×(n−m) ) as an F q -basis. Then Proof. Take g in Stab GLn(Fq) (U I ). Note that U I g = (A, 0 m×(n−m) ) and since A is invertible, then (A, 0) generates U I . Then B can take any value, but C needs to be invertible, to ensure that g is. We keep the above notation in what follows. for L such that U = U I L, L ∈ GL n (F q ).
Proof. Note first that any m-dimensional subspace U is of the form U = U I L for some L in GL n (F q ). Take g ∈ Stab GLn(Fq) (U), then by definition showing that LgL −1 ∈ Stab GLn(Fq) (U I ), that is g ∈ L −1 Stab GLn(Fq) (U I )L. Conversely, take an element L −1 gL ∈ L −1 Stab GLn(Fq) (U I )L, then and L −1 gL indeed belongs to the stabilizer of U.
Using the above lemma, we have that 2.2. Storage capacity. The storage capacity (or number of stored symbols in F q ) for every node is m, This is because a subspace U of dimension m means that the corresponding node actually stores U o T ∈ F m q , where we recall that o ∈ F 1×n q is the data object to be stored. This notion was introduced in [1]. Under the hypothesis that a stored object o ∈ F 1×n q should be recoverable from any k nodes, the minimal value of m is n/k.

Fault tolerance.
The ability to recover a stored object o ∈ F 1×n q from any k nodes, thus providing protection against any N − k failures is rephrased as: Note that when m = 1, then, recalling the connection with classical codes presented in the introduction, every node stores one column of a generator matrix of a linear code, and the property of fault tolerance just discussed is that of a maximum distance separable (MDS) code.
For arbitrary k, there is no formula to evaluate dim(U i1 + . . . + U i k ), apart from using iteratively the well known formula when k = 2 which states that Example 1. Consider the Grassmannian G 2 (3, 5), and let G = g be the subgroup of GL 5 (F 2 ) generated by Consider the orbit code UG, where U = U I has for basis The length N of the orbit code UG is Indeed, g has order 4 and Stab G (U) is trivial, since G intersects trivially Stab GL5(F2) (U) which is formed of matrices whose first 3 × 3 block is invertible (see Lemma 1). The orbit code UG is U, This corresponds to a storage code where the size of the object o is n = 5, every storage node stores m = 3 symbols, e.g., the first node corresponding to the subspace giving the following storage allocation: The data object o may be retrieved out of any two nodes, since, from (2) dim(Ug i + Ug j ) = 2 dim(Ug i ) − 1 = 5 for all i = j. Indeed, two distinct subspaces intersect in a subspace of dimension 1.

2.4.
Repair. As pointed out in the introduction, the main difference between a storage code and an erasure code is that a storage code should be amenable to repair, namely, the code should be such that the data stored at one node can be computed from a (small) subset of other nodes, without (necessarily) having to decode the object first. Concretely, a repair of one failure is done as follows: a node downloads data from several, possibly all live nodes, and from the data gathered, recomputes the codeword coefficient lost because of the failure. The parameters of importance are typically the communication cost of the repair, called repair bandwidth, which is also related to the number of live nodes contacted.
• Decomposing the stored data per node into m pieces is beneficial to the communication cost: it allows a repair to download part of the stored data. The optimal repair bandwidth per failed node is m, since at least the content of a failed node must be communicated for a repair to be successful. • To speed up repairs, contacting few live nodes is beneficial [10]. The optimal number of nodes is thus 2 in the case of one failure (since less than 2 means that a repetition code is used), or 1 in the (partial) collaborative case.
One may consider either repair of one failure at a time, or (possibly) wait for several failures to occur before repairing t of them together. Joint repair of multiple failures is often done collaboratively [2,13] as follows: a subset of nodes handle the repair, they each download some amount of information, perform the necessary computations on their data, but also further exchange data among each other, thus involving t − 1 nodes in the exchange process. If strictly less than t − 1 nodes are involved in the exchange, we speak of partial collaboration. Collaboration is known to be beneficial to the repair process [2,13] in terms of reducing the repair bandwidth.
Example 2. We continue Example 1, where we have for o of size 5 In case of one node failure, the subspace Ug i may be computed from the knowledge of a subspace of dimension 1 from each of the other Ug j , j = i, which follows from the fact that dim(Ug i ∩ Ug j ) = 1 for all i = j. For example, if Node 1 were to fail, it can be recomputed using o 1 from Node 4, o 2 from Node 3, and o 3 from Node 2. This code instance has been reported in [11], not in the language of orbit codes, but as a code whose repair bandwidth is minimal.
While the motivation example presented above is optimal for the case of one failure, most of our focus next will be on the collaborative case.

Instances of cyclic orbit codes using companion matrices
We next propose a family of cyclic orbit codes based on companion matrices and compute the parameters of the corresponding storage codes.
We first discuss basic properties of codes, namely length and fault tolerance, before proposing code constructions.
3.1. Basic properties. The following is probably well known and is proven for the sake of completeness.
Lemma 3. Let G = g be the subgroup of GL n (F q ) generated by the n × n companion matrix , p 0 = 0. Then the order of g is the smallest positive integer l such that p(x) divides x l − 1.
Proof. It is well known that p(x) is the minimal polynomial of the companion matrix One advantage to deal with companion matrices is that we are sure that no matter the choice of U, the resulting code will not be trivial (that is, containing U only). Proposition 1. Let g be the companion matrix of p(x) as in (4), and let U be an m-dimensional subspace in G q (m, n). Then the orbit code U g is not trivial (|U g | ≥ 2).
Proof. Consider g as a linear map from F n q to F n q , and F n q as an F q [x]-module over the polynomial ring F q [x] [3], its invariant subspaces are given by the Smith normal form of xI n − g, a diagonal matrix whose diagonal coefficients are called elementary divisors, which we denoted by d i . They are computed as follows. Compute the i × i minors of and let d i denote the greatest common divisor of all the i × i minors. Then d 1 = d 2 = . . . = d n−1 = ±1, which shows that there is no invariant subspace of dimension m, 1 ≤ m ≤ n − 1.
While any choice of U does give a non-trivial orbit code, different choices of U may give different sizes of orbit codes, as illustrated next.
. Since x 4 +x+1 is an irreducible polynomial, let ω be a root, that is ω 4 = ω+1, and Since ω is a primitive element of F 2 4 , the order of G is 15.
Consider U I ∈ G 2 (2, 4) with canonical basis U I = 1 0 0 0 0 1 0 0 . By Lemma 1, the stabilizer of U I under G is trivial, since G intersects trivially Stab GL4(F2) (U I ), which is formed of matrices whose first 2×2 block is invertible. Therefore the length of the code U I G is 15. The length of the code can more directly be seen to be 15 by invoking Lemma 4 below.
To illustrate the fact that a change in the choice of U may change the length of the corresponding orbit code, we look for powers of g i whose set of of invariant subspaces is non-empty. Take g 5 , given by and as in Proposition 1, and keeping the same notation, compute the Smith normal form of xI 4 −g 5 , to find that d 1 = d 2 = 1, while d 3 = x 2 +x+1, and d 4 = x 4 +x 2 +1. Therefore the invariant factors are Since Ug 5 = U, Ug 10 = (Ug 5 )g 5 = U, and the stabilizer of U under G has cardinality 3, given by so that the orbit code UG, with U = U I L, is of length 5, while U I G is of length 15.
The following result tells the length of the considered orbit codes from companion matrices when q = 2.
Lemma 4. Let g be the companion matrix of p(x), with g and p(x) as in (4), G = g , and let U I ∈ G q (m, n) be the subspace generated by a canonical basis as above. If q = 2, then the stabilizer Stab G (U I ) is trivial. Consequently the size of the orbit code is the order of g.
Proof. Let l be the order of g, and suppose that the stabilizer of U I under G = g is not trivial, that is, there exists an s, 0 < s < l, such that U I g s = U I . Then by Note that g s · g = g · g s , therefore the first m rows of g s · g and g · g s are equal, and given respectively by where a i , b i , c i denote the respective ith row of A, B and C. Equating coefficientwise shows that A = a 11 I m , b 1 = 0, c 1 = (a 11 , 0, ..., 0).
Repeating the same computation by noting that the first m rows of g s+1 · g equal those of g · g s+1 , we get where only the jth coordinate of c j is non-zero. Therefore g s = a 11 I n , and since q = 2, the only choice is a 11 = 1. This is a contradiction, since g has order l > s.
Note that the same argument breaks at g s = a 11 I n for q = 2. For example, when q = 3, p(x) = x 3 + 2, then g has order 6, and g 3 = 2I 3 .

3.2.
Code construction I: t failures with minimized bandwidth. We saw above that under the same group action, UG and U I G may yield different code lengths, due to different stabilizers. In this section, we thus consider the canonical case U I G.
Lemma 5. Take U, U ∈ G q (n − 1, n), U = U . Then U and U intersect in a subspace of dimension n − 2.
The following lemma describes the behavior of intersection of three subspaces, and shows that the considered orbit codes exhibit a particular structure, namely any three subspaces intersect in a subspace of dimension n − 3.
Lemma 6. Take U, U , U three distinct elements of G q (n − 1, n). Then U, U and U intersect in a subspace of dimension either n − 2 or n − 3. When U, U , U belong to an orbit code U g with g the companion matrix of p(x) as in (4), the dimension of their intersection is n − 3.
Consider now the case where the intersection is n − 2. Suppose there exist three subspaces A, B, C which intersect in a subspace of dimension n − 2. Let D be another subspace. Then D intersects B in a subspace of dimension n − 2. Either this subspace is A ∩ B ∩ C, or not. We will suppose not, and show that this yields a contradiction. Then since B and D each are (n − 1)-dimensional, it must be that B ∩ D is formed by an (n − 3)-dimensional subspace of A ∩ B ∩ C, and a one-dimensional subspace that belongs to B, and not to A, or to C. Now D also intersects C in an (n−2) subspace, and it already intersects it in a (n−3)-subspace, therefore the intersection of C and D further contains a one dimensional subspace that belongs to C, and not to A and B. But by now, the (n − 1)-dimensional subspace D is fully determined, it is made of a (n − 3)-dimensional subspace that belongs to A∩B ∩C, and two other one-dimensional subspaces, one, say c, belonging to C (and no to A or B) and one, say b, belonging to B (and not to C or A). Finally, D must intersect A in a (n − 2)-dimensional subspace. So either b or c must belong to A. But this not possible, because if b belongs to A, then the intersection between B and A becomes of dimension n − 1, and similarly for if c were to belong to A, then the intersection of A and C would be n − 1.
This shows that if there exist three subspaces that intersect in a subspace of dimension n − 2, then any other subspace will intersect them in the same subspace of dimension n − 2. Clearly this configuration cannot happen for the orbit code generated from a companion matrix. To see this, it is enough to consider Ug, Ug 2 and Ug 3 to see that Ug 3 contains a one-dimensional subspace which is common to Ug 2 but not to Ug.
We propose next a simple construction which will turn out to provide the optimal repair bandwidth, since it requires per failure the download of exactly the stored amount per node. Proposition 2. Let g be the companion matrix of p(x) as in (4) and let U I contain a canonical basis of U I ∈ G 2 (n − 1, n). Then the orbit code UG has the following properties: 1. it is of length l which is the order of g, 2. the object is retrieved by contacting any two nodes, Furthermore, for n ≥ 4, if p(x) is chosen as in Corollary 1, then the repair of t failures, t ≥ 2, is done by downloading n − 2 elements of F 2 from one node for each failure, and exchanging one element of F 2 between two repair nodes.
Proof. The claim on the length comes from Lemma 4. Label the l storage nodes from 0 to l − 1. By assumption, the ith node stores the element Ug i of the orbit UG of U under the right action of G, i = 0, 1, ..., l − 1.
To retrieve a stored object o ∈ F 1×l 2 from any 2 nodes, or equivalently to protect against any l − 2 failures, we need that for a choice of 2 subspaces from the code UG, dim(U i1 + U i2 ) = n, and the claim follows from Lemma 5. Recall Subsection 2.2 for counting the size of elements downloaded/repaired. Consider any four distinct nodes say s, v, i, j, respectively storing Ug s , Ug v , Ug i , Ug j . Let A = Ug i ∩ Ug s be the intersection of node i and s, it is of dimension n − 2 by the above lemma, and similarly, set B = Ug j ∩ Ug v . We claim that dim(A + B) = n. Since we need to show that dim(A ∩ B) = n − 4. Write Ug i = g 1 , ..., g n−2 , g i0 , Ug j = g 1 , ..., g n−2 , g j0 . Then A = Ug s ∩ Ug i = g 1 , ...g s0−1 , g s0+1 , ..., g n−2 , g i0 , otherwise the nodes i, j and s would intersect in the same subspace of dimension n − 2, which is not possible by Lemma 6, and for the same reason B = Ug v ∩ Ug j = g 1 , ...g v0−1 , g v0+1 , ..., g n−2 , g j0 . Without loss of generality, suppose that s 0 < v 0 . Then A ∩ B = g 1 , ..., g s0−1 , g s0+1 , ..., g v0−1 , g v0+1 , ...g n−2 which has dimension n − 4. Suppose that t nodes have failed, say node w, w = 0, . . . , t − 1, which each downloads from node w+t the subspace Ug w ∩Ug w+t of dimension n−2 (the labeling of the nodes is done for simplicity and without loss of generality). Each repaired node, after the download phase, is missing only one 1-dimensional subspace. By the above claim, any pair A := Ug w ∩ Ug w+t , B := Ug w ∩ Ug w +t has the property that dim((Ug w ∩Ug w+t )+(Ug w ∩Ug w +t )) = n, thus every repaired node can contact one other node to complete the repair process. If v 1 , . . . , v l ∈ A, ask the symbol n i=l+1 a i v i from B in node w . Iterate this process for the missing basis vector at other nodes.
We remark that this code requires the download of n − 1 symbols per failure, for a storage of n − 1 symbols per node, thus is using the minimal possible bandwidth. It is a collaborative code for t = 2, since two nodes are participating to the repair, and they are exchanging data among each other, and a partially collaborative code for t ≥ 3, since then each repaired node only needs to communicate with one other node. We store them in node 0 to 4. Assume that node 1 and node 4 failed. To repair node 1, download {(0010), (0001)} from node 2, to repair node 4, download {(1000), (0100)} from node 0, then during collaboration, the node repairing node 1 can compute (0011) and send it, and the node repairing node 4 sends (0100) in exchange. Note that the strategy is not unique. To repair node 1, download alternatively {(0001), (0110)} from node 3, to repair node 4, get {(1100), (1111)} from node 2, then the node repairing node 1 can get (0011) and the one repairing node 4 can get (0111) from the collaboration.
3.3. Code construction III: spreads. In this section, we interpret a known family of storage codes [9] in the language of orbit codes, using the result from [14] that shows the connection between spreads and orbit codes.
Consider the finite fields F q ⊂ F q m ⊂ F q n , with m|n. It is well known that F q n is an n-dimensional vector space over F q , of which F q m and its cosets are mdimensional subspaces. They thus form a spread, that is a collection of disjoint subspaces whose union is F q n . Spreads to design storage codes have been investigated in [9], and can be obtained as a particular case of the proposed construction of orbit codes using companion matrices. For this, two ingredients are needed: (1) g must be the companion matrix of a primitive polynomial p(x), meaning that p(x) is monic and irreducible of degree n, and of order l = q n − 1, namely, roots of p(x) are primitive elements of F q n , they generate the cyclic group F * q n and (2) U is chosen so as to contain a basis for F q m .
Proposition 3. Suppose that m|n, and consider the field extension F q n /F q m . Let U contain a basis of F q m , and g be the companion matrix of a primitive polynomial p(x) such that p(ω) = 0 and ω = F * q m . Then U g is an orbit code of length q n −1 such that Ug i ∩ Ug j is trivial whenever i = j, and the union of Ug i , i = 1, . . . , n m is F q n .
Proof. Note that µ := ω n/m is a generator of F * q m , and that {1, µ, . . . , µ m−1 } forms an F q -basis of F q m . Form a matrix U where each row contains µ i = ω in/m written in an F q -basis of F q n , i = 0, . . . , m − 1. Then the action of g corresponds to multiplication by ω, and the claims follow from the fact that as a F * q n can be written as the union of ω i F * q m , i = 1, . . . , q n −1 q m −1 .
More discussion about spread codes is also available in [14].
, it is a primitive polynomial, and let g be its companion matrix Let ω be a root of p(x), that is ω 4 = ω + 1, also ω has order 15 and is a primitive element of F 16 . Therefore ω 5 is a generator of F * 4 , and an F 2 -basis for F 4 is Then the orbit code U g forms a spread, it has length 5, and we obtain a known storage code [9, Example 1], namely

Instances of cyclic orbit codes using diagonal matrices
We describe in this section cyclic orbit codes based on diagonal matrices, and obtain Reed-Solomon codes as a particular case, and a family of storage codes which will turn out to give optimal parameters.
Let ω be the primitive element of F q . Consider the cyclic group G = g of GL n (F q ) generated by the n × n diagonal matrix where n < |F q |. Then the order of g is that of w, which is |F q | − 1. Indeed, for g i to be the identity for some i, we at least need w i to be 1, but then all other powers (w j ) i will be 1 as well, j = 2, . . . , n − 1. The length N of the orbit code UG is In fact, the orbit code UG is given by This corresponds to a storage allocation where each node stores the inner product of the object o with a column of a generator matrix of a Reed-Solomon code.

4.2.
A code construction for t failures, t ≥ 1. A variation of the above construction can be obtained by tensor products. Consider the orbit code UG where G = g ⊗ I m for g the diagonal matrix given by k ≥ 1, and I m the m-dimensional identity matrix, and take for a basis of U Note that the generator g chosen for this construction is similar to (5), but for the dimension k ≥ 1. Since n is the size of the object, we choose k and m such that km = n. Since the order of g ⊗ I m is still |F q | − 1, this does not change the size N of the orbit code UG.
Proposition 4. Let g be the k-dimensional diagonal matrix above, and let U ⊗ I m = [1, w, . . . , w k−1 ] ⊗ I m be a basis of the m-dimensional subspace U ∈ G q (m, n), n = km. Then the orbit code UG has the following properties: 1. the object is retrieved by contacting any k nodes, 2. the repair of t failures, t ≥ 1, is done by contacting any k nodes. Proof.
1. If any k nodes i 1 , . . . , i k are contacted, then we obtain k columns of a Vandermonde matrix, each tensored by I m , thus a k × k invertible submatrix tensored by I m , and the data object o can be recovered. 2. Without loss of generality, we label the t failed nodes from 1 to t. Then t live nodes each contact k nodes, say the ith node among those t live nodes connects to nodes i 1 , . . . , i k and downloads only the one-dimensional subspace, corresponding to the ith row of U g ij ⊗ I m , j = 1, . . . , k. Again using the fact that we obtain k columns of a Vandermonde matrix, the ith node computes a part of the object, given

Performance of storage codes
We briefly summarize known bounds on storage codes, to evaluate the proposed codes, and substantiate our earlier claim that they provide low repair bandwidth.
Recall that we encode an object o of size n over F q into N m pieces and distribute them into N storage nodes, each of the nodes stores m coefficients in F q . 5.1. Bounds. Denote by α the storage capacity of every storage node, to keep the usual notation found in the literature, here, α = m. The typical known trade-off bounds for storage codes involve α, and the amount of data communicated during repair. They all assume that the storage codes have the property that any k out of N storage nodes contain enough information to recover the object o.
(1) If the system repairs one failure at a time, the communication cost in terms of bandwidth, called repair bandwidth, is γ = dβ per node involved in the repair, where d is the number of live nodes contacted, and from each of them, β coefficients in F q are downloaded.
(2) If the system waits for a threshold t of failures before starting the repair, then γ = dβ + (t − 1)β per node, where t nodes each download β symbols of F q from d live nodes, and exchange β symbols among each others. This scenario falls into the collaborative repair setting [2,13].
(3) The collaborative repair process can be refined so that the exchange phase of data does not involve all the repair nodes, which is called partially collaborative repair [5]. This is the most general setting as of now, and it subsumes the previous two cases. We introduce the parameter s to characterize the degree of collaboration, and t − s counts the number of repair nodes involved in the exchange process.
There are two extreme regimes when it comes to storage capacity and repair bandwidth: one minimizes the storage capacity, it is called the Minimum Storage Repair (MSR) point, while the other minimizes the repair bandwidth γ (this is Minimum Repair Bandwidth (MBR) point. At MSR point, as mentioned in Subsection 2.2, the storage capacity α = m is n/k: indeed, this follows from the assumption that any k nodes contain enough information to recover o of length n. At MBR point, the minimum repair bandwidth γ per node is equal to α = m: this surely is the least amount of data to be transferred for a node to be repaired (see also Subsection 2.4).
What the trade-off computations between α and γ tell [5] which is not obvious is that once α = m = n/k, γ cannot be arbitrarily low, and vice-versa, once γ = α, α cannot be arbitrarily low. The lowest values that the different parameters achieve are in fact: The meaning of the parameters involved is summarized for convenience in n size of an object k any choice of k nodes allow the object retrieval α storage capacity per node γ repair bandwidth per node β download repair bandwidth β exchange repair bandwidth t threshold at which a repair process is triggered t − s number of other repair nodes involved in collaboration Table 1. Parameters involved in the bounds for storage codes.
When s = 1, we get the full collaboration case ((2) above), while s = t corresponds to the situation with no collaboration ((1) above).

5.2.
Comparison. Let us consider the collaborative code construction of Subsection 3.2 for t = 2. An object o of length n is stored in N nodes, each of the nodes storing one codeword of the orbit code U I G, U I ∈ G 2 (n − 1, n) with canonical basis U I , thus α = n − 1. The group G acting is G = g with g the companion matrix of the polynomial p(x) whose order is l, so that N = l. When p(x) = n i=0 x i , we know from Proposition 2 that k = 2, β = n − 2, and β = 1. We notice that the total amount of data downloaded for repair is 2(n − 2) + 2 = 2n − 2, which is n − 1 per node, suggesting that the code is at MBR. At MBR, we should have, using d = 1, k = 2, t − s = 1: When n = 4, the code in Subsection 3.2 has α = γ = n − 1 = 3 = 3n 4 , β = n − 2 = 2 = n 2 , β = 1 = n 4 , which is indeed at MBR (α is minimized). When n > 4, the code has parameters: which, as mentioned above, satisfies α = γ, but α is not minimized. The number of contacted nodes is optimal. Let us consider the partially collaborative code construction of Subsection 3.2 for t ≥ 3. As discussed above for the collaborative code construction, this partially collaborative code construction only changes the value of t, but t − s still equals to 1. We know then that the repair bandwidth is still n − 1, which suggests that the code is at MBR. Since the optimal values of α, γ at MBR point are related to the value of t − s which is not changed, the minimized α is obtained by n = 4 (which indeed is a collaborative phase since three failures cannot happen when n = 4). For n ≥ 4, still α = γ, but α is not minimized, while the number of contacted nodes stays optimal. The gap between the optimal storage and the value of α for this construction is shown on Figure 1, for different values of n between 4 and 10. We remark that optimal code constructions at MBR for partial collaboration are not known as of now. This suggests that a deeper study of automorphism groups as a future work to get new/better codes for partial collaboration.
Consider finally the code given in Subsection 4.2. Set m to be t−s+1, which sets the level of collaboration, namely there is collaboration among t − s repair nodes. Then the size of the object is n = k(t − s + 1), each node has a storage capacity of  Figure 1. The storage code proposed in Subsection 3 is optimal with respect to the minimum repair bandwidth, but not with respect to the storage capacity α. This shows the optimal value of α with respect to the storage needed for the construction, as a function of n. When n = 4, our construction is optimal. We set d = 1, k = 2 and t − s = 1. α = t−s+1, t−s ≥ 1. This construction can been seen as a new interpretation of the construction of [6] which fits the minimum storage regime (MSR), since α = n/k. The total repair bandwidth γ is γ = k + (t − s), 1 ≤ s ≤ t, since every repair node downloads k amount of data, and exchanges t − s of it.