Computing sharp recovery structures for Locally Recoverable codes

TL;DR

This paper presents an algorithm to compute optimal recovery structures for any linear code, enhancing local recoverability and providing insights into code locality and dual distance, with complexity analysis and examples.

Contribution

It introduces a novel algorithm that efficiently finds the most concise recovery structures for linear codes, advancing the design of locally recoverable codes.

Findings

Algorithm computes minimal recovery structures

Provides locality and dual distance of codes

Includes complexity analysis and practical examples

Abstract

A locally recoverable code is an error-correcting code such that any erasure in a single coordinate of a codeword can be recovered from a small subset of other coordinates. In this article we develop an algorithm that computes a recovery structure as concise posible for an arbitrary linear code $\mathcal{C}$ and a recovery method that realizes it. This algorithm also provides the locality and the dual distance of $\mathcal{C}$. Complexity issues are studied as well. Several examples are included.

Tables

Table 1. Table 1. Running times of Algorithm 2 for random [ 10 , 4 ] 10 4 [10,4] codes.

Field size $q$	Running time	Vectors in $\mathrm{𝙻𝚒𝚜𝚝𝟸}$
$q=2$	$0.009$ seconds	$34$
$q=3$	$0.022$ seconds	$113$
$q=5$	$0.322$ seconds	$665$
$q=7$	$0.727$ seconds	$1010$
$q=11$	$3.649$ seconds	$4308$
$q=13$	$5.887$ seconds	$5743$
$q=17$	$13.141$ seconds	$10950$
$q=19$	$18.210$ seconds	$14013$
$q=23$	$40.876$ seconds	$22069$

Table 2. Table 2. Running times of Algorithm 2 for random codes of different parameters.

Field size $q$	Parameters	Running time
$q=2$	$[50,10]$	$0.84$ s.
$q=2$	$[50,12]$	$2.984$ s.
$q=2$	$[50,15]$	$11.103$ s.
$q=2$	$[50,20]$	$215.47$ s.
$q=2$	$[70,15]$	$78.4$ s.
$q=3$	$[50,10]$	$20380.70$ s.
$q=5$	$[25,7]$	$14793.754$ s.

Equations

$$k+d+\lceil \frac{k}{\text{mbox}loc(\mathcal{C})}\rceil \le n+2$$

$$k+d+\lceil \frac{k}{\text{mbox}loc(\mathcal{R})}\rceil \le n+2$$

$$x_i=-w_i^{-1}(\mathbf{w}\cdot \mathbf{x}).$$

$$G=\left(\begin{array}[]{ccccccccc}1&0&0&0&\alpha&1+\alpha&\alpha&1+\alpha&1\\ 0&1&0&0&1+\alpha&\alpha&1&1+\alpha&0\\ 0&0&1&0&0&\alpha&1+\alpha&1&1+\alpha\\ 0&0&0&1&\alpha&1&\alpha&0&1+\alpha\end{array}\right)\in\mathbb{F}_{4}^{4\times 9}.$$

$$\mathbf{x}{\prec }_T\mathbf{y}if\{\begin{array}{l}\text{mbox}wt(\mathbf{x})<\text{mbox}wt(\mathbf{y});or\\ \text{mbox}wt(\mathbf{x})=\text{mbox}wt(\mathbf{y})and(i_{x_1},\dots ,i_{x_n}){\prec }_{lex}(i_{y_1},\dots ,i_{y_n})\end{array}$$

$$\mathbf{x}{\to }_{{\lambda }_1\cdot {\mathbf{t}}_1}{\mathbf{v}}_1,{\mathbf{v}}_1{\to }_{{\lambda }_2\cdot {\mathbf{t}}_2}{\mathbf{v}}_2,\dots {\mathbf{v}}_{n_1}{\to }_{{\lambda }_s\cdot {\mathbf{t}}_s}\mathbf{v},$$

$$\begin{array}[]{ccc}\mathbf{x}\rightarrow_{\mathbf{t}_{1}}\mathbf{v}_{1}=(1,0,0,1,1,1)&\hbox{ and }&\mathbf{x}\rightarrow_{\mathbf{t}_{2}}\mathbf{v}_{2}=(0,0,1,0,0,0)\end{array}$$

$$G=\left(\begin{array}[]{ccc}1&0&1\\ 0&1&1\end{array}\right)\in\mathbb{F}_{2}^{2\times 3}.$$

$${\tt L}=\left\{\begin{array}[]{cc}(0,1,0)-(0,0,1),&(1,0,0)-(0,0,1),\\ (1,0,0)-(0,1,0),&(0,1,1)-(0,0,0),\\ (1,0,1)-(0,0,0),&(1,1,0)-(0,0,0)\end{array}\right\}$$

$${\mathbf{m}}_i{\to }_{{\lambda }_1\cdot {\mathbf{t}}_1}{\mathbf{v}}_1,{\mathbf{v}}_1{\to }_{{\lambda }_2\cdot {\mathbf{t}}_2}{\mathbf{v}}_2,\dots {\mathbf{v}}_{n_1}{\to }_{{\lambda }_s\cdot {\mathbf{t}}_s}0.$$

$$\begin{array}[]{lcl}\mathbf{t}_{1}=(\alpha,\alpha,\alpha+1,0,0,0,0,\alpha+1,0)&&\mathrm{supp}(\mathbf{t}_{1})=\left\{1,2,3,8\right\}\\ \mathbf{t}_{2}=(\alpha,\alpha+1,0,\alpha,1,0,0,0,0)&&\mathrm{supp}(\mathbf{t}_{2})=\left\{1,2,4,5\right\}\\ \mathbf{t}_{3}=(\alpha,1,0,0,0,1,\alpha+1,0,0)&&\mathrm{supp}(\mathbf{t}_{3})=\left\{1,2,6,7\right\}\\ \mathbf{t}_{4}=(\alpha,0,0,1,1,0,0,0,\alpha)&&\mathrm{supp}(\mathbf{t}_{4})=\left\{1,3,4,9\right\}\\ \end{array}$$

$$\begin{array}[]{ccc}R_{1}=\mathrm{supp}(\mathbf{t}_{1})\setminus\{1\}&R_{2}=\mathrm{supp}(\mathbf{t}_{1})\setminus\{2\}&R_{3}=\mathrm{supp}(\mathbf{t}_{1})\setminus\{3\}\\ R_{4}=\mathrm{supp}(\mathbf{t}_{2})\setminus\{4\}&R_{5}=\mathrm{supp}(\mathbf{t}_{2})\setminus\{5\}&R_{6}=\mathrm{supp}(\mathbf{t}_{3})\setminus\{6\}\\ R_{7}=\mathrm{supp}(\mathbf{t}_{3})\setminus\{7\}&R_{8}=\mathrm{supp}(\mathbf{t}_{1})\setminus\{8\}&R_{9}=\mathrm{supp}(\mathbf{t}_{4})\setminus\{9\}.\\ \end{array}$$

$$\mathcal{O}\left(n\log (q)\left((q-1)(n-k)+D(q-1)(n-k)-D\right)\right)\sim \mathcal{O}\left(Dn(n-k)(q-1)\log (q)\right).$$

$$D\le \sum _{i=0}^{n-k+1}\left(\genfrac{}{}{0ex}{}{n}{i}\right)(q-1{)}^i.$$

Full text

1. Introduction

Locally recoverable codes were introduced in [7], motivated by the use of coding theory techniques applied to distributed and cloud storage systems, in which the information is distributed over several nodes. The growth of the amount of stored data make the loss of information due to node failures a major problem. To obtain a reliable storage, when a node fails we want to be able to recover the data it contains by using information from the other nodes. This is called the repair problem. A naive method to solve it, is to replicate the same information in different nodes. A more clever strategy is to protect the data by using error-correcting codes, [13, 15]. As typical examples of this last solution, we can mention Google and Facebook, that use Reed-Solomon (RS) codes in their storage systems. The procedure is as follows: the information to be stored is a long sequence $b$ of symbols, which are elements of a finite field $\mathbb{F}_{\ell}$. This sequence is cut into blocks, $b=b_{1},b_{2},\dots$, of the same length, say $t$. According to the isomorphism $\mathbb{F}_{\ell}^{t}\cong\mathbb{F}_{\ell^{t}}$, each of these blocks can be seen as an element of the finite field $\mathbb{F}_{q}$, $q=\ell^{t}$. Fix an integer $k<q$. The vector $\mathbf{b}=(b_{1},\dots,b_{k})\in\mathbb{F}_{q}^{k}$ is encoded by using a RS code of dimension $k$ over $\mathbb{F}_{q}$, whose length $n$, $k<n<q$, is equal to the number of nodes that will be used in its storage. Then we choose $\alpha_{1},\dots,\alpha_{n}\in\mathbb{F}_{q}$, and send $b_{1}+b_{2}\alpha_{i}+\dots+b_{k}\alpha_{i}^{k-1}$ to the $i$-th node. When a node fails, we may recover the data it stores by using Lagrangian interpolation from the information of any other $k$ available nodes.

The above solution to the repair problem is not optimal. When $k$ is small with respect to $n$, then the transmission rate $k/n$ obtained by our encoding method is poor. For large values of $k$ the scheme is wasteful since $k$ symbols must be used to repair just one. Thus it is natural to wonder if there exists other codes allowing the repair of lost encoded data more efficiently than RS codes, that is by making use of smaller amount of information.

Roughly speaking we can set the repair problem in terms of coding theory as follows: Let $\mathcal{C}$ be a linear code of length $n$, dimension $k$ and minimum distance $d$ over the field $\mathbb{F}_{q}$. A coordinate $i\in\{1,\dots,n\}$ is locally recoverable with locality $r$ if there is a recovery set $R\subseteq\{1,\dots,n\}$ with $i\not\in R$ and $\#R=r$, such that for any codeword $\mathbf{x}\in\mathcal{C}$, an erasure in position $i$ of $\mathbf{x}$ can be recovered by using the information given by the coordinates of $\mathbf{x}$ with indices in $R$. A collection of recovery sets for all coordinates is a recovery structure. The code $\mathcal{C}$ is locally recoverable (LRC) with locality $\leq r$ if there exists a recovery structure of locality $\leq r$, that is to say, if any coordinate is locally recoverable with locality at most $r$. The locality of $\mathcal{C}$, $\mbox{loc}(\mathcal{C})$ is the smallest $r$ verifying this condition. For example, it is not difficult to prove that MDS codes of dimension $k$ have locality $k$.

Every code $\mathcal{C}$ with minimum distance $d>1$ is locally recoverable with locality $\mbox{loc}(\mathcal{C})\leq k$. In practice we are interested in LRC’s admitting recovery sets as small as possible, in relation to the other parameters $[n,k,d]$ of $\mathcal{C}$. Thus the locality has become a fundamental parameter of a code when it is used for local recovery purposes. Unfortunately the explicit computation of recovery structures, and even the computation of the locality of a specific code, have been revealed as difficult problems. As regards the latter, there exist some known bounds on it. Perhaps the most interesting of them is the following Singleton-like bound: the locality of $\mathcal{C}$ verifies the relation, [7],

[TABLE]

which gives a lower bound on $\mbox{loc}(\mathcal{C})$. However it is known that this bound is not sharp, see Example 1 below. Codes reaching equality in (1) are called optimal.

Much research has been devoted in recent years to the repair problem and many recovery structures are known for different types of codes. See for instance [4, 9, 16, 17] to be aware of the variety of methods used to that purpose. Nevertheless for most of the recovery structures currently available in the literature, it is unknown whether or not they can be refined to obtain other simpler ones.

In this article we develop an algorithm that computes a recovery structure as concise as posible for an arbitrary code $\mathcal{C}$. This algorithm also gives the locality and the dual distance of $\mathcal{C}$. The article is organized as follows: in Section 2 we summarize all necessary facts about LRC codes and recovery structures that we shall need in the rest. The algorithm is developped in Section 3, where complexity issues are treated as well. Finally, in Section 4 we present some experimental results and running times for several examples of codes.

2. Recovery Structures

In this section we give some formal definitions and facts that will be used in the rest of this article.

Let $\mathcal{C}$ be a linear code of length $n$ over $\mathbb{F}_{q}$. Let $\mathbf{G}$ be a generator matrix of $\mathcal{C}$ and $\mathbf{c}_{1},\dots,\mathbf{c}_{n}$ be its columns. A set $R\subset\{1,\dots,n\}$ with $i\notin R$, is a recovery set for coordinate $i$ if $\mathbf{c}_{i}$ is a linear combination of $\{\mathbf{c}_{j}:j\in R\}$, see [7]. Note that, this is equivalent to say that $\dim\mathcal{C}(R)=\dim\mathcal{C}(R\cup\{i\})$, where $\mathcal{C}(S)$ is the projection of $\mathcal{C}$ on the coordinates in $S$ (see Proposition 1 below). Thus the notion of recovery set does not depend on the chosen generator matrix. As we shall prove later, if $R$ is a recovery set for $i$, then for every codeword $\mathbf{x}\in\mathcal{C}$, the coordinate $x_{i}$ can be obtained from the other coordinates $x_{j}$ with indices $j\in R$.

By an elementary recovery structure for $\mathcal{C}$ we mean a family $\mathcal{R}=(R_{i})_{i=1,\dots,n}$, such that for all $i=1,\dots,n$, $R_{i}$ is a recovery set for the coordinate $i$. Thus a recovery structure allows us to recover an erasure at any position in a codeword. The structure $\mathcal{R}$ is called minimal if so is each $R_{i}$, that is, if no proper subset of $R_{i}$ is a recovery set for $i$. A general recovery structure for $\mathcal{C}$ is the union of elementary structures, that is to say a collection of recovery sets for each coordinate. From now on, all structures considered in this article will be elementary.

The code $\mathcal{C}$ is locally recoverable (LRC) if it admits a recovery structure $\mathcal{R}=(R_{i})_{i=1,\dots,n}$. In such case, the number $\mbox{loc}_{i}(\mathcal{R})=\#R_{i}$ is the locality of $\mathcal{R}$ with respect to coordinate $i$, $1\leq i\leq n$. The locality of $\mathcal{R}$ is $\mbox{loc}(\mathcal{R})=\max\{\#R_{i}:1\leq i\leq n\}$. As different recovery structures are possible for the same code, it is natural to ask if given one of them, $\mathcal{R}$, there exits another, $\mathcal{R}^{\prime}$, with smaller recovery sets. So we define \mbox{loc}_{i}(\mathcal{C})=\min\{\mbox{loc}_{i}(\mathcal{R}):\mathcal{R}\mbox{ is a recovery structure for \mathcal{C}}\}, $1\leq i\leq n$, and \mbox{loc}(\mathcal{C})=\min\{\mbox{loc}(\mathcal{R}):\mathcal{R}\mbox{ is a recovery structure for \mathcal{C}}\}. If $\mbox{loc}_{i}(\mathcal{R})=\mbox{loc}_{i}(\mathcal{C})$ for all $i=1,\dots,n$, then $\mathcal{R}$ will be called sharp. Clearly $\mathcal{R}$ is sharp if and only if $\sum_{i=1}^{n}\#R_{i}\leq\sum_{i=1}^{n}\#R^{\prime}_{i}$ for any structure $\mathcal{R^{\prime}}=(R^{\prime}_{i})_{i=1,\dots,n}$ of $\mathcal{C}$, so the locality of a code is always reached through a sharp structure.

Remark 1*.*

A structure $\mathcal{R}$ of $\mathcal{C}$ is optimal if $\mbox{loc}(\mathcal{R})$ reaches equality in the following bound

[TABLE]

which is derived from (1). Note that optimality is not enough to ensure sharpness. For instance, in [16, Example 1] the authors show a $[9,4,5]$ LRC code with a recovery structure $\mathcal{R}$ formed by sets of cardinality 2. Then $\mathcal{R}$ is optimal. Let $\mathcal{R}^{\prime}$ be the structure whose sets are obtained by adding a (random) coordinate to the recovery sets of $\mathcal{R}$. Thus $\mbox{loc}(\mathcal{R})=3$ and so $\mathcal{R}$ is optimal as well, but not sharp. This example also shows that the locality of a code can not, in general, be obtained from (1), not even when an optimal structure is available.

Let $d$ be the minimum distance of $\mathcal{C}$. If $d=1$ then, up to reordering, $\mathcal{C}$ contains the codeword $(1,0,\dots,0)$, so the first coordinate can not have any recovery set and $\mathcal{C}$ is not a LRC. At the other end, if there exists a coordinate $i$ such that $x_{i}=0$ for all codeword $\mathbf{x}\in\mathcal{C}$ (that is, if $\mathcal{C}$ is a degenerate code), it is not necessary to recover this coordinate from the others. So in all that follows we will assume that $\mathcal{C}$ is a nondegenerate code of minimum distance $d>1$. Let us investigate in a little more in detail the recovering properties for these codes. As a notation, $\mathcal{C}^{\perp}$ will be the dual of $\mathcal{C}$. The support of a vector $\mathbf{x}\in\mathbb{F}_{q}^{n}$ is the set $\mbox{\rm supp}(\mathbf{x})=\{i\in\{1,\dots,n\}:x_{i}\neq 0\}$ and its weight is $\mbox{\rm wt}(\mathbf{x})=\#\mbox{\rm supp}(\mathbf{x})$.

Proposition 1**.**

*Let $\mathcal{C}$ be a code of length $n$ and let $R\subseteq\{1,\dots,n\}$. The following statements are equivalent.

(i) $R$ is a recovery set for coordinate $i$;

(ii) $\dim\mathcal{C}(R)=\dim\mathcal{C}(R\cup\{i\})$;

(iii) there exists a codeword $\mathbf{w}\in\mathcal{C}^{\perp}$ such that $i\in\mbox{\rm supp}(\mathbf{w})\subseteq R\cup\{i\}$.*

Proof.

The equivalence between (i) and (ii) follows from the fact that a generator matrix of $\mathcal{C}(R)$ can be obtained from the submatrix of $\mathbf{G}$ given by the columns with indices in $R$, and so $\dim\mathcal{C}(R)=\mbox{rank}\{\mathbf{c}_{j}:j\in R\}$. Let $\mathbf{w}\in\mathbb{F}_{q}^{n}$. The equivalence between (i) and (iii) follows from the fact that $\mathbf{w}\in\mathcal{C}^{\perp}$ if and only if $\mathbf{G}\mathbf{w}^{T}=\mathbf{0}$, that is if and only if $\sum w_{j}\mathbf{c}_{j}=\mathbf{0}$. ∎

Given a word $\mathbf{w}\in\mathcal{C}^{\perp}$, for any codeword $\mathbf{x}\in\mathcal{C}$ we have that $\mathbf{w}\cdot\mathbf{x}=0$, where $\cdot$ stands for the usual inner product in $\mathbb{F}_{q}^{n}$, $\mathbf{w}\cdot\mathbf{x}=w_{1}x_{1}+\dots+w_{n}x_{n}$. So, if $i\in\mbox{supp}(\mathbf{x})\subseteq\mbox{supp}(\mathbf{w})$, then $x_{i}$ can be obtained from $\{x_{j}:j\in\mbox{supp}(\mathbf{w})\setminus\{i\}\}$ as

[TABLE]

Thus such $\mathbf{w}$ provides a recovery set and a recovery method for coordinate $i$.

Corollary 1**.**

Let $\mathbf{w}\in\mathcal{C}^{\perp}$, $\mathbf{w}\neq\mathbf{0}$. Then $\mbox{\rm supp}(\mathbf{w})\setminus\{i\}$ is a recovery set for all $i\in\mbox{\rm supp}(\mathbf{w})$.

A codeword $\mathbf{x}\in\mathcal{C}$ is called minimal if for every $\mathbf{y}\in\mathcal{C}$, $\mathbf{y}\neq\mathbf{0}$, such that $\mbox{supp}(\mathbf{y})\subseteq\mbox{supp}(\mathbf{x})$ we have $\mbox{supp}(\mathbf{y})=\mbox{supp}(\mathbf{x})$.

Given a coordinate $i\in\{1,\dots,n\}$, the codeword $\mathbf{x}$ is said to be $i$-minimal if $i\in\mbox{supp}(\mathbf{x})$ and for every $\mathbf{y}\in\mathcal{C}$, such that $i\in\mbox{supp}(\mathbf{y})\subseteq\mbox{supp}(\mathbf{x})$ we have $\mbox{supp}(\mathbf{y})=\mbox{supp}(\mathbf{x})$.

Lemma 1**.**

*Let $\mathbf{x}\in\mathcal{C}$. The following conditions are equivalent.

(i) $\mathbf{x}$ is minimal;

(ii) $\mathbf{x}$ is $i$-minimal for all $i\in\mbox{\rm supp}(\mathbf{x})$;

(iii) $\mathbf{x}$ is $i$-minimal for some $i\in\mbox{\rm supp}(\mathbf{x})$.*

Proof.

(i)$\Rightarrow$(ii)$\Rightarrow$(iii) are clear. Let us prove (iii)$\Rightarrow$(i). Let $\mathbf{x}$ be $i$-minimal for some $i\in\mbox{supp}(\mathbf{x})$. If $\mathbf{x}$ were not minimal, it would exist $\mathbf{y}\in\mathcal{C}$, $\mathbf{y}\neq\mathbf{0}$, such that $\mbox{supp}(\mathbf{y})\subset\mbox{supp}(\mathbf{x})$. Furthermore $y_{i}=0$, since $\mathbf{x}$ is $i$-minimal. Let $j\in\mbox{supp}(\mathbf{y})$ and let $\mathbf{z}=\mathbf{x}-(x_{j}y_{j}^{-1})\mathbf{y}\in\mathcal{C}$. Then $z_{i}=x_{i}\neq 0$ and $\mbox{supp}(\mathbf{z})\subset\mbox{supp}(\mathbf{x})$, which contradicts that $\mathbf{x}$ is $i$-minimal ∎

Corollary 2**.**

*Let $\mathcal{C}$ be a code of length $n$ and let $i\in R\subseteq\{1,\dots,n\}$. The following statements are equivalent.

(i) $R$ is a minimal recovery set for coordinate $i$;

(ii) there exists a minimal codeword $\mathbf{w}\in\mathcal{C}^{\perp}$ such that $\mbox{\rm supp}(\mathbf{w})=R\cup\{i\}$.*

Proof.

(i)$\Rightarrow$(ii): Let $\mathbf{w}$ be the codeword ensured by item (iii) of Proposition 1. If either $\mathbf{w}$ were not $i$-minimal or $\mbox{\rm supp}(\mathbf{w})\neq R\cup\{i\}$, then it would exists $\mathbf{v}\in\mathcal{C}^{\perp}$ such that $i\in\mbox{\rm supp}(\mathbf{v})\subset R\cup\{i\}$. According to Corollary 1, $S=\mbox{supp}(\mathbf{v})\setminus\{i\}$ is a recovery set for $i$, which contradicts that $R$ is minimal. Lemma 1 ensures that $\mathbf{v}$ is a minimal word of $\mathcal{C}^{\perp}$. (i)$\Rightarrow$(ii): $R=\mbox{supp}(\mathbf{w})\setminus\{i\}$ is a recovery set for $i$, again according to Corollary 1. If $R$ were not minimal, then neither would $\mathbf{w}$ be $i$-minimal, according to Proposition 1. ∎

So a recovery structure $\mathcal{R}=(R_{i})_{i=1,\dots,n}$ for $\mathcal{C}$ is equivalent to a family $\mathcal{W}=(\mathbf{w}_{i})_{i=1,\dots,n}$ of words of $\mathcal{C}^{\perp}$ such that $i\in\mbox{supp}(\mathbf{w}_{i})$: just take $R_{i}=\mbox{supp}(\mathbf{w}_{i})\setminus\{i\}$. Besides, as seen before, the equalities $\mathbf{w}_{i}\cdot\mathbf{x}=0$, $i=1,\dots,n$, provide a method to compute any erased coordinate $x_{i}$ in a word $\mathbf{x}\in\mathcal{C}$. $\mathcal{R}$ is minimal iff so is each $\mathbf{w}_{i}$; and $\mathcal{R}$ is sharp iff $\sum_{i=1}^{n}\#\mbox{supp}(\mathbf{w}_{i})$ is minimal among all families $\mathcal{W}^{\prime}=(\mathbf{w}^{\prime}_{i})_{i=1,\dots,n}$ of words of $\mathcal{C}^{\perp}$ such that $i\in\mbox{supp}(\mathbf{w}^{\prime}_{i})$.

Corollary 3**.**

Let $\mathcal{C}$ be a code and let $\mathcal{C}^{\perp}$ be its dual. Then ${\rm loc}(\mathcal{C})\geq d(\mathcal{C}^{\perp})-1$.

The bound on ${\rm loc}(\mathcal{C})$ given by the previous corollary improves sometimes the bound given by (1), which shows again that the latter is not necessarily sharp.

Example 1**.**

Let us consider a $[9,4]$ code $\mathcal{C}$ over $\mathbb{F}_{4}=\{0,1,\alpha,1+\alpha\}$ with $\alpha^{2}=1+\alpha$. According to the Griesmer bound, its minimum distance verifies that $d(\mathcal{C})\leq 5$. Indeed such a code with $d(\mathcal{C})=5$ exists. Consider, for example, the one given by the generator matrix

[TABLE]

$\mathcal{C}$ is obtained from the $[12,6]$ extended Quadratic Residue code by shortenning twice and then puncturing; its minimum distance is $5$, see [12]. From (1) its locality verifies ${\rm loc}(\mathcal{C})\geq 2$. But being $\mathcal{C}$ an almost MDS code, its dual $\mathcal{C}^{\perp}$ must be a $[9,5,4]$ code, see [6, Theorem 7]. Thus ${\rm loc}(\mathcal{C})\geq d(\mathcal{C}^{\perp})-1=3$. In fact, as we shall compute later in Example 5, we have ${\rm loc}(\mathcal{C})=3$.

Remark 2*.*

There exists a remarkable connection between the repair problem and the theory of secret sharing. A secret sharing scheme (SSS) is a method for distributing a secret $s\in\mathbb{F}_{q}$ among a set of $n$ participants, each of whom receives a piece of the secret or share. The scheme is designed in such a way that only the authorized coalitions of participants can recover the secret, by pooling the shares of its members.

SSS can be obtained from codes in several ways. The first method to do that was given in [3]. Let $\mathcal{C}$ be a $[n+1,k]$ code with generator matrix $\mathbf{G}$. A dealer computes the codeword $\mathbf{x}=\mathbf{z}\mathbf{G}$ from a random vector $\mathbf{z}\in\mathbb{F}_{q}^{k}$ subject to $x_{n+1}=s$, the secret to be shared. The share of the $i$-th participant is $x_{i}$, $1\leq i\leq n$. Thus, a coalition $R$ of participants is authorized if and only if $R$ is a recovery set for coordinate $n+1$. The locality $\mbox{\rm loc}_{n+1}(\mathcal{C})$ is exactly the smaller size of an authorized coalition. Massey [11] later introduced the concept of minimal codeword and observed that the minimal authorized coalitions correspond to the minimal words of $\mathcal{C}^{\perp}$ whose support contains the coordinate $n+1$, that is, to the minimal recovery sets for the coordinate $n+1$. Therefore, the methods developed in this article can be adapted to compute the minimal authorized coalitions in this type of SSS.

3. Computing Sharp Recovery Structures

In this section we develop an algorithm that provides a sharp recovery structure for an arbitrary linear code $\mathcal{C}$, in terms of minimal codewords of its dual $\mathcal{C}^{\perp}$, that is through a family $\mathcal{W}=(\mathbf{w}_{i})_{i=1,\dots,n}$ of minimal words of $\mathcal{C}^{\perp}$ such that $i\in\mbox{supp}(\mathbf{w}_{i})$. Consequently, it also provides a method for recovery, following the formula of equation (3), the locality of $\mathcal{C}$ and its dual distance, as the smallest weight of a word in $\mathcal{W}$. The methods we will use come from the theory of Gröbner basis, however we will try to avoid Gröbner basis terminology.

Let $\zeta$ be a primitive element of $\mathbb{F}_{q}^{*}$. We define a total ordering $\prec_{T}$ on $\mathbb{F}_{q}^{n}$ as follows

[TABLE]

where $i_{x_{j}}$ is the element of $[0,q-1]\cup\{-\infty\}$ such that $\zeta^{i_{x_{j}}}=x_{j}$ or $i_{x_{j}}=-\infty$ if $x_{i}=0$, and the same definition holds for the vector $\mathbf{y}$. Note that our ordering $\prec_{T}$ is mainly the order given by the Hamming weight with an extra total ordering for breaking ties. Remark that any other total order in the indices, different from $lex$ for breaking ties, will define an alternative order $\prec^{\prime}_{T}$ that would be equally valid for our purposes.

Example 2**.**

Let us consider the vectors $\mathbf{x}=(1,\alpha,0,\alpha^{2})$ and $\mathbf{y}=(\alpha^{2},\alpha,0,\alpha)$ over $\mathbb{F}_{4}^{4}$, being $\alpha$ a primitive element of $\mathbb{F}_{4}^{*}$ with $\alpha^{2}=1+\alpha$. Then, $\mathbf{x}\prec_{T}\mathbf{y}$ since $\mbox{wt}(\mathbf{x})=\mbox{wt}(\mathbf{y})$ and $(0,1,-\infty,2){\prec_{lex}}(2,1,0,1)$.

Next we recall some concepts from Gröbner basis theory that we will use in what follows. We say that a codeword $\mathbf{s}\in\mathcal{C}$ is expresed as a syzygy if we write $\mathbf{s}=\mathbf{s}_{1}-\mathbf{s}_{2}$, with $\mathbf{s}_{1},\mathbf{s}_{2}\in\mathbb{F}_{q}^{n}$ and $\mathbf{s}_{2}\prec_{T}\mathbf{s}_{1}$. In this case $\mathbf{s}_{1}$ is called the leading term of the syzygy. Every codeword can be trivially expresed in this form, by taking $\mathbf{s}_{2}=\mathbf{0}$. Given two vectors $\mathbf{t},\mathbf{x}\in\mathbb{F}_{q}^{n}$, we say that $\mathbf{t}$ reduces $\mathbf{x}$ if $\mathbf{x}+\mathbf{t}\prec_{T}\mathbf{x}$. Then, the vector $\mathbf{v}=\mathbf{x}+\mathbf{t}$ is called the reduction of $\mathbf{x}$ by $\mathbf{t}$ and will be denoted by $\mathbf{x}\rightarrow_{\mathbf{t}}\mathbf{v}$. Let $\mathcal{T}\subseteq\mathbb{F}_{q}^{n}$. The vector $\mathbf{v}$ is a reduction of $\mathbf{x}$ by $\mathcal{T}$ if for a non-negative integer $s\in\mathbb{N}$ there are elements $\lambda_{i}\in\mathbb{F}_{q}$ and $\mathbf{t}_{i}\in\mathcal{T}$ $i=1,\ldots,s$ such that

[TABLE]

and we will denote it by $\mathbf{x}\rightarrow_{\mathcal{T}}\mathbf{v}$. Note that, in general, a vector has not a unique reduction by a set $\mathcal{T}$.

Example 3**.**

Given the set $\mathcal{T}=\left\{\mathbf{t}_{1}=(0,1,1,0,0,1),\mathbf{t}_{2}=(1,1,0,1,1,0)\right\}\subseteq\mathbb{F}_{2}^{6}$ and the vector $\mathbf{x}=(1,1,1,1,1,0)\in\mathbb{F}_{2}^{6}$. We can give two different reductions of $\mathbf{x}$ by $\mathcal{T}$:

[TABLE]

We will compute a special set $\mathcal{T}\subseteq\mathbb{F}_{q}^{n}$ of syzygies called a Gröbner test-set as follows.

1. (1)

First we list $\tt L$ all the non-zero syzygies of the code $\mathcal{C}$ and we sort them with respect to the ordering $\prec_{T}$ in its leading terms. 2. (2)

Then, we go incrementally through the list $\tt L$. We add to the set $\mathcal{T}$ and we remove from $\tt L$ all those elements such that at least one of its non-zero coordinates from its leading term is equal to a multiple of the leading term of an element in $\mathcal{T}$. 3. (3)

Finally we reduce the trailing terms using the list $\tt L$.

Example 4**.**

[Toy Example] Consider a binary code $\mathcal{C}$ with generator matrix

[TABLE]

To obtain a Gröbner test-set $\mathcal{T}$ for $\mathcal{C}$ we proceed as follows.

We initialize $\tt L$ with all the non-zero syzygies of the code $\mathcal{C}$ and we sort them w.r.t. $\prec_{T}$.

[TABLE]

• •

We add $(0,1,0)-(0,0,1)$ to $\mathcal{T}$ and we omit from $\tt L$ all multiples of $(0,1,0)$.

• •

We add $(1,0,0)-(0,1,0)$ to $\mathcal{T}$ and we omit from $\tt L$ all multiples of $(1,0,0)$.

The process ends because the list $\tt L$ is empty. Now $\mathcal{T}$ is a Gröbner test-set.

Note that $\mathcal{T}$ depends only on the code $\mathcal{C}$ and the ordering $\prec_{T}$ and can be computed from a set of generators by means of the Gröbner basis procedure based on linear algebra FGLM techniques, stated in [10]. Moreover the reduction of a vector in $\mathbb{F}_{q}^{n}$ by this $\mathcal{T}$ is show to be unique and independent of the order of the reductions in (5). Algorithms 1 gives the reduction of an element $\mathbf{x}$ by a Gröbner test set $\mathcal{T}$.

The Gröbner test set $\mathcal{T}$ defines a reduction that allows to check whether a vector is in the code $\mathcal{C}$ if and only it reduces to the zero vector. Furthermore it allows us to compute a sharp recovery structure for $\mathcal{C}$.

Proposition 2**.**

Let $\mathcal{T}$ be a Gröbner test set for the code $\mathcal{C}$ and let $\mathbf{x}\in\mathbb{F}_{q}^{n}$. Then $\mathbf{x}\in\mathcal{C}$ if and only if $\mathbf{x}$ reduces to $\mathbf{0}$ by $\mathcal{T}$.

Proof.

For a proof see [10]. ∎

The key idea on which our algorithm is based in the following result.

Proposition 3**.**

Let $\mathcal{T}$ be a Gröbner test set for the code $\mathcal{C}^{\perp}$. For each coordinate $i$ let $\mathcal{T}_{i}=\{\mathbf{t}\in\mathcal{T}:i\in\mathrm{supp}(\mathbf{t})\}$ and let $\mathbf{t}_{i}$ be an element of minimum Hamming weight in $\mathcal{T}_{i}$. Then $(\mathrm{supp}(\mathbf{t}_{i})\setminus\{i\})_{i=1,\dots,n}$ is a sharp recovery structure for $\mathcal{C}$.

Proof.

Let $\mathbf{m}_{i}\in\mathcal{C}^{\perp}$ be the smallest $i$-minimal codeword with respect to the total ordering $\prec_{T}$. We will prove that $\mbox{wt}(\mathbf{t}_{i})=\mbox{wt}(\mathbf{m}_{i})$. Note that since $\mathbf{m}_{i}$ is in the code $\mathcal{C}^{\perp}$ then $\mathbf{m}_{i}\rightarrow_{\mathcal{T}}\mathbf{0}$. There is a non-negative integer $s\in\mathbb{N}$ such that the set of reductions in Algorithm 1 for $\mathbf{m}_{i}\rightarrow_{\mathcal{T}}\mathbf{0}$ can be expresed in the form

[TABLE]

Thus there must be a vector $\mathbf{t}=\lambda_{j}\mathbf{t}_{j}$, $j\in\{1,\ldots,s\}$ such that it is the first one involved in the chain of reductions in (6) with $i\notin\mathrm{supp}(\mathbf{v_{i}})$. Indeed it is clear that $j=1$ since $i$ is in the support of the codewords $\mathbf{v}_{1},\ldots,\mathbf{v}_{i-1}$ and $\mathbf{m}_{i}\succ_{T}\mathbf{v}_{1}\succ_{T}\ldots\succ_{T}\mathbf{v}_{j-1}$ which contradices the minimality of $\mathbf{m}_{i}$ with respect to the total ordering $\prec_{T}$. Without loss of generality we can suppose that $\mathbf{t}_{j}=\mathbf{t}_{i}$.

Let $\mathbf{r}=\mathbf{t}-\mathbf{m}_{i}$ and note that $\mathbf{r}\prec_{T}\mathbf{m}_{i}$ since $\mathrm{wt}(\mathbf{r})=\mathrm{wt}(\mathbf{v}_{1})<\mathrm{wt}(\mathbf{m}_{i})$. Suppose now that $\mbox{wt}(\mathbf{m}_{i})<\mbox{wt}(\mathbf{t})=\mbox{wt}(\mathbf{t}_{i})$, hence $\mathbf{r}$ is expresed as the syzygy $\mathbf{t}-\mathbf{m}_{i}$. The syzygy $\mathbf{r}$ can be used to reduce $\mathbf{t}$ as follows $\mathbf{t}\rightarrow_{\mathbf{r}}\mathbf{m}_{i}$, since $(\mathbf{t}-\mathbf{r})=\mathbf{m}_{i}$ without cancelling the $i$-th position which is a contradiction with the fact that $\mathbf{t}_{j}\in\mathcal{T}$ since the test set contains syzygies that cannot be reduced. Hence $\mbox{wt}(\mathbf{m}_{i})=\mbox{wt}(\mathbf{t})$ and we are done. ∎

According to Proposition 3, the minimal words $\mathbf{w}_{i}\in\mathcal{C}^{\perp}$ providing a sharp recovery structure for $\mathcal{C}$ can always be found in a test set $\mathcal{T}$, and it is not necessary to look for them in the whole code $\mathcal{C}^{\perp}$. This idea is used in Algorithm 2 that provides such a sharp recovery structure for $\mathcal{C}$. Roughly speaking, this algorithm applies Gaussian elimination to a large sparse matrix (namely list $\mathcal{G}_{T}$ in this case), taking into account that we stop once we have enough codewords to cover all indices in $\{1,\ldots,n\}$. Note that it only requires a parity check matrix $H$ of the code $\mathcal{C}$ to run.

Remark 3*.*

If $q=2$, then the parity check matrix of some codes can be seen as the adjacency matrix of a non-directed graph. In these cases, Proposition 3 ensures that the procedure in Algorithm 2 performs the Horton’s algorithm for computing a minumum cycle basis of the graph [5, 8]. Thus, our Algorithm 2 extends the Horton’s algorithm from cycles in graphs to recovery sets in codes.

Example 5**.**

Let us consider again the code $\mathcal{C}$ of Example 1. A parity check matrix of $\mathcal{C}$ is easily obtained from its generator matrix. The Gröbner test set consists of 49 codewords. The following four among them define a sharp recovery structure $\mathcal{R}=\left\{R_{1},\ldots,R_{9}\right\}$ for $\mathcal{C}$

[TABLE]

with

[TABLE]

In particular, ${\rm loc}(\mathcal{C})=3$ and $d(\mathcal{C}^{\perp})=4$, as announced in Example 1.

Proposition 4**.**

Algorithm 2 is correct and provides a sharp recovery structure for the code $\mathcal{C}$ with parity check matrix $H$.

Proof.

The first stage involves the initalization of the algorithm with a list $\tt List1$ whose elements are the rows of the parity check matrix $H$ and all their non-zero scalar multiples. That is: $\tt List1=\left\{\lambda h_{i}\hbox{ with }\lambda\in\mathbb{F}_{q}\setminus\{0\}\hbox{ and }h_{i}\hbox{ row of }H\right\}$ with $(n-k)(q-1)$ items. Now, the list $\mathcal{G}_{T}$ that we will use during the algorithm is initialized with the elements of $\tt List1$ and we add to all this elements the zero vector as label (to represent the trivial syzygies of the elements in the list). In another list, namely $\tt List2$, we have all vectors of $\mathbb{F}_{q}^{n}$ of weight less or equal to $n-k+2$, we sort this list w.r.t. $\prec_{T}$.

Then, at each step we remove the first element $\mathbf{w}$ from the list $\tt List2$. If any of the vectors $\mathbf{w}+\mathbf{h}$ with $\mathbf{h}$ being an item of $\tt List1$ coincide with the $j$-th element of $\mathcal{G}_{T}$ then, the difference between $\mathbf{w}$ and the label corresponding to $\mathcal{G}_{T}[j]$ form a codeword of minimal support of the dual code of $\mathcal{C}$. Otherwise, we add the items: $\left\{\mathbf{w}+\mathbf{h}\mid\forall\mathbf{h}\hbox{ item of }\tt List1\right\}$ as new elements of the list $\mathcal{G}_{T}$ with the vector $\mathbf{w}$ as label (i.e. we add the new reduced syzygies). We repeat this process until we get enough codewords to achieve a sharp recovery structure for the code $\mathcal{C}$. ∎

Proposition 5**.**

Let $\mathcal{C}$ be a linear code of length $n$ and dimension $k$ over $\mathbb{F}_{q}$. If the ground field operations need one unit time, then Algorithm 2 applied to $\mathcal{C}$ takes time $\mathcal{O}(Dn(n-k)(q-1)\mathrm{log}(q))$, where $D$ is the total number of iterations of the algorithm.

Proof.

The proof is similar to the proof of [10, Theorem 4.3], adapted to the changes made in Algorithm 2 versus [10, Algorithm 2]. The hardest part of our algorithm is the management of the list $\mathcal{G}_{T}$. In each main loop iteration, up to $(n-k)(q-1)$ new elements are added to the list $\mathcal{G}_{T}$, then compared and finally redundancy is eliminated. Note that comparing two vectors in $\mathbb{F}_{q}^{n}$ requires $\mathcal{O}(n\log(q))$ field operations. At iteration $i$, after inserting the new elements in the list $\mathcal{G}_{T}$, we have at most $(q-1)(n-k)+(i(q-1)(n-k)-i)$ elements. Here, the first summand corresponds to the elements that initialized $\tt List1$, while the second one comes from the fact that at each iteration the first element is removed and we add $(n-k)(q-1)$ new elements. If $D$ is an upper bound for the number of iterations of Algorithm 2, this gives a total time of order

[TABLE]

∎

Remark 4*.*

(1) The number of iterations in Algorithm 2, $D$, is upper bounded by the fact that the weight of a minimal codeword is at most $n-k+1$ [1, Lemma 2.1]. Thus, it follows that

[TABLE]

(2) Note that this algorithm also provides the dual distance of $\mathcal{C}^{\perp}$, as the smallest weight of one of the minimal words in the obtained recovery strucuture of $\mathcal{C}$. Remember that computing the minimum distance of a linear code is a NP complete problem, [2], which explains the high complexity of our algorithm. Note, however, that as in the case of the minimum distance, a recovery structure must be calculated only once per code.

4. Experimental Results

Algorithm 2 has been implemented with the program Sagemath [14]. In the following tables we summarize the average running times for several examples of codes, obtained with an Intel $\circledR$ CoreTM 2 Duo $2.8$ GHz. The experiments are performed as follows: We first generate a full rank random matrix of size $k\times n$ over $\mathbb{F}_{q}$ using the command random_matrix (GF(q),k,n); then we take the corresponding code $\tt C$ and compute its dual $\tt Cd=C.dual\_code()$; if the minimum distances of $\tt C$ and $\tt Cd$ are greater than 1, we apply Algorithm 2.

For each base field size $q$, the experiment has been performed on $20$ random codes $\tt C$. The obtained results are shown in Tables 1 and 2. In Table 1 all codes have length $n=10$ and dimension $k=4$. The first column contains the base field sized $q$. Second column indicates the average running time for the computation of a sharp recovery structure for $\tt C$, measured in seconds. Third column shows the average number of vectors in $\tt List2$. In Table 2, we deal with codes of different parameters, which are indicated in the second column. Here we have omitted the average number of vectors in $\tt List2$.