Locally Repairable Convolutional Codes with Sliding Window Repair

TL;DR

This paper introduces Locally Repairable Convolutional Codes (LRCCs) that enable efficient local and sliding-window global repair in distributed storage, achieving optimal erasure correction and flexibility through adjustable parameters.

Contribution

The work presents a novel class of LRCCs with adjustable window parameters, a Singleton-type bound for their column distances, and an explicit construction of partial MDP codes based on sum-rank distance convolutional codes.

Findings

LRCCs enable local and global erasure repair with adjustable parameters.

Achieved Singleton-type bound for column distances in LRCCs.

Constructed partial MDP codes that attain the bound for certain parameters.

Abstract

Locally repairable convolutional codes (LRCCs) for distributed storage systems (DSSs) are introduced in this work. They enable local repair, for a single node erasure (or more generally, $ \partial - 1 $ erasures per local group), and sliding-window global repair, which can correct erasure patterns with up to $ {\rm d}^c_j - 1 $ erasures in every window of $ j+1 $ consecutive blocks of $ n $ nodes, where $ {\rm d}^c_j $ is the $ j $th column distance of the code. The parameter $ j $ can be adjusted, for a fixed LRCC, according to different catastrophic erasure patterns, requiring only to contact $ n(j+1) - {\rm d}^c_j + 1 $ nodes, plus less than $ \mu n $ other nodes, in the storage system, where $ \mu $ is the memory of the code. A Singleton-type bound is provided for $ {\rm d}^c_j $. If it attains such a bound, an LRCC can correct the same number of catastrophic erasures in a window of length $ n(j+1) $ as an optimal locally repairable block code of the same rate and locality, and with block length $ n(j+1) $. In addition, the LRCC is able to perform the flexible and somehow local sliding-window repair by adjusting $ j $. Furthermore, by adjusting and/or sliding the window, the LRCC can potentially correct more erasures in the original window of $ n(j+1) $ nodes than an optimal locally repairable block code of the same rate and locality, and length $ n(j+1) $. Finally, the concept of partial maximum distance profile (partial MDP) codes is introduced. Partial MDP codes can correct all information-theoretically correctable erasure patterns for a given locality, local distance and information rate. An explicit construction of partial MDP codes whose column distances attain the provided Singleton-type bound, up to certain parameter $ j=L $, is obtained based on known maximum sum-rank distance convolutional codes.

Equations

$$\mathcal{C}=\left\{u(D)G(D)\mid u(D)\in \mathbb{F}[D{]}^k\right\}.$$

$$\delta =\delta (\mathcal{C})=\sum _{i=1}^k{e}_i\text{and}\mu =\mu (\mathcal{C})=\max \{e_1,e_2,\dots ,e_k\}.$$

$$\mathcal{C}=\{v(D)\in \mathbb{F}[D{]}^n\mid v(D)H(D{)}^T=0\}.$$

$$\mathrm{wt}(v(D))=\sum _{j\in \mathbb{N}}\mathrm{wt}(v_j).$$

$$d(\mathcal{C})=\min \{\mathrm{wt}(v(D))\mid v(D)\in \mathcal{C}\text{ and }v(D)\ne 0\}.$$

$$G_{j}^{c}=\left[\begin{array}[]{cccc}G_{0}&G_{1}&\ldots&G_{j}\\ &G_{0}&\ldots&G_{j-1}\\ &&\ddots&\vdots\\ &&&G_{0}\end{array}\right],$$

$$\begin{array}{rl}{\mathcal{C}}_j^c=& \left\{(u_0,u_1,\dots ,u_j)G_j^c\mid u_0,u_1,\dots ,u_j\in {\mathbb{F}}^k,u_0\ne 0\right\}\\ \stackrel{\ast }{=}& \left\{(v_0,v_1,\dots ,v_j)\mid \sum _{h\in \mathbb{N}}{v}_h{D}^h\in \mathcal{C},v_0\ne 0\right\}\subseteq {\mathbb{F}}^{(j+1)n},\end{array}$$

$$d_j^c(\mathcal{C})=\min \left\{{\mathrm{wt}}_H(v)\mid v\in {\mathcal{C}}_j^c\right\},$$

$$d_j^c(\mathcal{C})\le (n-k)(j+1)+1.$$

$$j\le L=\lfloor \frac{\delta }{k}\rfloor +\lfloor \frac{\delta }{n-k}\rfloor .$$

$$(v_{t-\mu },v_{t-\mu +1},\dots ,v_{t-1},v_t^{\ast },v_{t+1}^{\ast },\dots ,v_{t+j}^{\ast })\in {\tilde{\mathbb{F}}}^{n(\mu +j+1)}$$

$$\begin{array}{rl}{\mathcal{C}}^0=& \left\{\sum _{j=0}^{\mu }{u}_j{G}_j\mid u_j\in {\mathbb{F}}^k,j=0,1,\dots ,\mu \right\}\\ =& \left\{v_{\mu }\in {\mathbb{F}}^n\mid v(D)=\sum _{j\in \mathbb{N}}{v}_j{D}^j\in \mathcal{C}\right\}\subseteq {\mathbb{F}}^n.\end{array}$$

$${\mathcal{C}}_{\Gamma }=\left\{v(D{)}_{\Gamma }\mid v(D)\in \mathcal{C}\right\}\subseteq \mathbb{F}[D{]}^{|\Gamma |}.$$

$$d_0^c(\mathcal{C})\le (n-k)-\left(\lceil \frac{k}{r}\rceil -1\right)(\partial -1)+1.$$

$$d_j^c(\mathcal{C})\le (n-k)(j+1)-\left(\frac{k(j+1)}{r}-1\right)(\partial -1)+1,$$

$${\mathcal{C}}_0=\{u{G}_0\in {\mathbb{F}}^n\mid u\in {\mathbb{F}}^k\}={\mathcal{C}}_0^c\cup \{0\}\subseteq {\mathbb{F}}^n$$

$$\Delta ={\Delta }_1\cup {\Delta }_2\cup \dots \cup {\Delta }_{\ell }\subseteq {\Gamma }_1\cup {\Gamma }_2\cup \dots \cup {\Gamma }_{\ell }$$

$$G_0^{\prime }=\left(I_{r,1},A_{0,1}|I_{r,2},A_{0,2}|\dots |I_{r,\ell },A_{0,\ell }|B_{0,1}|B_{0,2}|\dots |B_{0,g-\ell }\right)\in {\mathbb{F}}^{k\times n},$$

$$I_k=\left(I_{r,1},I_{r,2},\dots ,I_{r,\ell }\right)\in {\mathbb{F}}^{k\times k}$$

$$\widetilde{G}_{j}^{c}=\left[\begin{array}[]{cccc}G_{0}^{\prime}&G_{1}^{\prime}&\ldots&G_{j}^{\prime}\\ &G_{0}&\ldots&G_{j-1}\\ &&\ddots&\vdots\\ &&&G_{0}\end{array}\right]\in\mathbb{F}^{(j+1)k\times(j+1)n},$$

$$G_h^{\prime }=\left(0_{k,r},A_{h,1}|0_{k,r},A_{h,2}|\dots |0_{k,r},A_{h,\ell }|B_{h,1}|B_{h,2}|\dots |B_{h,g-\ell }\right)\in {\mathbb{F}}^{k\times n},$$

$$\begin{array}{rl}{v}_0& =\left(1,0_{r-1},a_{0,1}|0_r,a_{0,2}|\dots |0_r,a_{0,\ell }|b_{0,1}|b_{0,2}|\dots |b_{0,g-\ell }\right),\\ v_1& =\left(0_r,a_{1,1}|0_r,a_{1,2}|\dots |0_r,a_{1,\ell }|b_{1,1}|b_{1,2}|\dots |b_{1,g-\ell }\right),\\ ⋮& \\ v_j& =\left(0_r,a_{j,1}|0_r,a_{j,2}|\dots |0_r,a_{j,\ell }|b_{j,1}|b_{j,2}|\dots |b_{j,g-\ell }\right),\end{array}$$

$$\begin{array}{rl}{a}_{0,2}=a_{0,3}=\dots =a_{0,\ell }& =0_{\partial -1},\\ a_{1,1}=a_{1,2}=a_{1,3}=\dots =a_{1,\ell }& =0_{\partial -1},\\ ⋮& \\ a_{j,1}=a_{j,2}=a_{j,3}=\dots =a_{j,\ell }& =0_{\partial -1},\end{array}$$

$$\begin{array}{rl}{\mathrm{wt}}_H(v)& \le (j+1)n-\ell (j+1)(r+\partial -1)+\partial \\ & =(j+1)n-(j+1)\ell r-((j+1)\ell -1)(\partial -1)+1\\ & =(n-k)(j+1)-\left(\frac{k(j+1)}{r}-1\right)(\partial -1)+1,\end{array}$$

$$M_{\mathcal{A}}\left(c\right)=\left[\begin{array}[]{cccc}c_{11}&c_{12}&\ldots&c_{1s}\\ c_{21}&c_{22}&\ldots&c_{2s}\\ \vdots&\vdots&\ddots&\vdots\\ c_{m1}&c_{m2}&\ldots&c_{ms}\\ \end{array}\right]\in\mathbb{F}_{q}^{m\times s},$$

$${\mathrm{wt}}_{SR}(c)=\sum _{i=1}^g\mathrm{Rk}(M_{\mathcal{A}}(c^{(i)})).$$

$${\mathrm{wt}}_{SR}(v(D))=\sum _{j\in \mathbb{N}}{\mathrm{wt}}_{SR}(v_j).$$

$$d_{SR}(\mathcal{C})=\min \{{\mathrm{wt}}_{SR}(v(D))\mid v(D)\in \mathcal{C}\text{ and }v(D)\ne 0\}.$$

$$d_{SR,j}^c(\mathcal{C})=\min \left\{{\mathrm{wt}}_{SR}(v)\mid v\in {\mathcal{C}}_j^c\right\},$$

$${\mathrm{wt}}_{SR}(c)=\sum _{i=1}^g\mathrm{Rk}(M_{\mathcal{A}}(c^{(i)}))\le \sum _{i=1}^g\mathrm{wt}(c^{(i)})=\mathrm{wt}(c),$$

Full text

Keywords: Convolutional Codes, Distributed Storage, Locally Repairable Codes, Locally Repairable Convolutional Codes, Sliding-Window Repair, Sum-Rank Metric.

1 Introduction

Locally repairable codes (LRCs) [11] are an important class of codes for Distributed Storage Systems (DSSs), since they allow to repair a single node by contacting and downloading the content of a small number (called locality) of other nodes (in contrast with MDS codes), while still being able to repair a large number of nodes in case of catastrophic erasures (in contrast with Cartesian products). LRCs are thus natural hybrids between MDS codes and Cartesian products of codes that enjoy both global and local erasure-correction capabilities simultaneously, given by global and local distances, respectively. Note that repair is typically used interchangeably with erasure correction in the storage literature. We will use both terms throughout this work.

LRCs have already been implemented in practice (see [13, 31] for instance). Optimal LRCs (meaning LRCs attaining optimal global distance for a given locality, local distance and information rate) for general parameters and field sizes that are linear in the code length were first obtained in [32]. LRCs capable of correcting all information-theoretically correctable global erasure patterns, for a given locality, local distance and information rate, were introduced in [4, 10] (where they are called partial MDS and maximally recoverable LRCs, respectively). As expected, maximally recoverable LRCs also attain optimal global distance. However, they can correct strictly more global erasure patterns than general optimal LRCs (see Remark 2) for the same parameters. Constructions of maximally recoverable LRCs with relatively small field sizes for general parameters have been given in [8, 24] (see also the references therein).

On the other hand, it is shown in [33] that maximum distance profile (MDP) convolutional codes provide an interesting alternative to MDS block codes since they admit sliding-window erasure correction: They can correct any erasure pattern such that there are no more than $(n-k)(j+1)$ erasures in any consecutive $j+1$ blocks of $n$ symbols (that is, $n(j+1)$ consecutive symbols), where $k/n$ is the rate of the code (see [33, Th. 3.1] or Fig. 2). Furthermore, the correction is performed somehow locally by sliding recursively the window of $j+1$ blocks, and the parameter $j$ may vary arbitrarily up to a certain constant $L$ determined by the degree (thus memory) of the convolutional code (see (2)). Therefore MDP convolutional codes already enable certain local and flexible repair, since the window size $n(j+1)$ can be chosen according to how catastrophic the erasure pattern is. Moreover, by adjusting and/or sliding a window of $j+1$ blocks (see Fig. 1), an MDP code can potentially correct in a window of size $n(j+1)$ more erasures than an MDS block code of the same rate and of block length $n(j+1)$. Unfortunately, in case of one single node erasure (most common case), sliding-window repair with $j=0$ still requires contacting and downloading the content of $\mu n$ extra symbols, where $\mu$ is the memory of the code, due to its convolutional nature.

Motivated by the discussion in the previous paragraph, we introduce in this work locally repairable convolutional codes (LRCCs). When being optimal in terms of global distance or maximal recoverability, LRCCs can repair a single node (or more generally, $\partial-1$ erasures per local group) by contacting $r<n$ (or even $r<k$) other nodes and simultaneously enable sliding-window repair (see Fig. 4), which can be set up flexibly according to different catastrophic erasure patterns (see Figs. 4 and 5), and which can potentially correct in a window of size $n(j+1)$ more erasures than an optimal or maximally recoverable locally repairable block code of the same rate and locality, and of block length $n(j+1)$ (see Fig. 1).

LRCCs also enable encoding and storing an unrestricted sequence of files, while locality remains constant and encoding and sliding-window repair complexities are all bounded (by the memory of the code). Furthermore, LRCCs can easily be turned into block codes by converting them into tail-biting convolutional codes, while the properties described above still hold.

We now illustrate with Example 1 and Fig. 1 the main advantages of LRCCs over block LRCs. For fairness, we compare optimal LRCCs with optimal LRCs.

Example 1**.**

Consider a $(6,3)$ convolutional code that encodes a stream of file vectors over a finite field $\mathbb{F}$, each of length $k=3$, into a stream of encoded vectors, each of length $n=6$.

Assume a node in the storage system stores a symbol over $\mathbb{F}$, and call block each set of $n=6$ coordinates supporting each encoded vector. In this example, each block forms a local group. If the code has locality $r=5$ and local distance $\partial=2$ (Section 3), it means that a single node erasure ($\partial-1$ node erasures) in each block may be repaired by only contacting the other $5$ nodes in that block.

The code can correct erasure patterns with up to ${\rm d}_{j}^{c}-1$ erasures in every window of $j+1$ consecutive blocks of $n$ symbols, where $j=0,1,2,\ldots$ can be adjusted. Assume that an erasure pattern as in Fig. 1 occurs, with $21$ erasures in a given window of $j+1=9$ blocks. If the LRCC has optimal $j$th column distance ${\rm d}_{j}^{c}$ (as in Corollaries 1 and 2), then ${\rm d}_{j}^{c}=18$, for $j=8$, and the code cannot correct such erasures considering such a window. Furthermore, an optimal block LRC with block length $(j+1)n=54$, dimension $(j+1)k=27$, locality $r=5$ and local distance $\partial=2$, also has global distance $18$ (see [11, Eq. (1)]), hence it cannot correct that erasure pattern either.

However, we may adjust the window for the LRCC. Consider instead windows of length $j^{\prime}+1=5$, as in Fig. 1. If the LRCC also has optimal $j^{\prime}$th column distance (as in Corollaries 1 and 2), then ${\rm d}_{j^{\prime}}^{c}=12$ for $j^{\prime}=4$. Observe that now every window of $j^{\prime}+1=5$ consecutive blocks of $n$ symbols contains at most $11$ erasures. Therefore, the LRCC may correct such an erasure pattern by sliding the new adjusted window of length $j^{\prime}+1=5$, whereas the optimal block LRC as in the previous paragraph cannot.

The disadvantage of the LRCC is that, in order to perform such an erasure correction, we need to read the content (which needs to be correct) of the $\mu$ blocks of $n$ symbols previous to such window (see Fig. 1), where $\mu$ is the memory of the LRCC.

Example 2**.**

Consider now a $(6,4)$ LRCC with locality $r=5$ and local distance $\partial=2$ (Section 3). Assume also that the code has memory $\mu=5$ and degree $\delta=20$ (Subsection 2.1) and that it is an optimal LRCC (as in Corollaries 1 and 2). As in Example 1, such an LRCC can correct the same number of erasures in any window consisting of $L+1=26$ consecutive blocks ($n(L+1)=156$ symbols) as an optimal block LRC of the same rate ($2/3$), same locality ($r=5$), same local distance ($\partial=2$) and total length $n(L+1)=156$. In both cases, such a number of erasures is $32=(n-k)(L+1)-\left\lceil\frac{k(L+1)}{r}\right\rceil+1$ (see Theorem 2 and [11, Eq. (1)], respectively).

However, the LRCC may correct any erasure pattern with up to $(n-k)(j+1)-\left\lceil\frac{k(j+1)}{r}\right\rceil+1$ erasures in any window of $n(j+1)$ consecutive nodes, for all $j=0,1,\ldots,L=25$. This only requires reading and downloading the content of the remaining nodes in that window (that is, $k(j+1)+\left\lceil\frac{k(j+1)}{r}\right\rceil-1$ symbols), plus another $\mu N=\mu(n-1)=25$ previous nodes (see Fig. 5). For instance, for $j=2$, we may repair any erasure pattern with up to $4$ erasures in any consecutive $18$ nodes ($3$ blocks of $6$ nodes), by contacting $14$ nodes in that window, plus another $\mu N=25$ previous nodes. The optimal LRC, in contrast, would always require contacting $124=k(L+1)+\left\lceil\frac{k(L+1)}{r}\right\rceil-1$ other nodes in order to repair any $4$ erasures in $3$ blocks of $6$ nodes, since at least one of these blocks contains $2$ erasures, which cannot be repaired locally.

Therefore, adjusting the window size when using an LRCC also reduces the number of nodes that need to be contacted. Thus sliding-window erasure correction of LRCCs provides a type of erasure correction in between local and global erasure correction.

Our main contributions are the following. We define LRCCs (Definition 10) and provide a Singleton-type bound on their column distances (Theorem 2), which measure the global sliding window repair capability of the code. We later define partial MDP codes (Definition 15), which can correct all information-theoretically correctable erasure patterns for the given local constrains and, in particular, attain the previous bound for as long as possible. We provide in Construction 1 a method for finding partial MDP codes based on outer MSRD convolutional codes (Theorem 4). By plugging in Construction 1 the MSRD convolutional codes from [21], we obtain an explicit family of partial MDP codes (Corollary 2) for general parameters. Their main disadvantage is their big global field size, although local fields are small. However, this is only an issue in terms of computational complexity, since nodes in DSSs typically store large amounts of data. Furthermore, our construction gives some field size to guarantee the existence of partial MDP codes, but constructions over smaller fields may be possible.

To conclude this introduction, we note that the use of streaming or convolutional codes for storage or as LRCs is not new. Binary tail-biting convolutional codes were proposed as LRCs in [7, 36], but sliding-window repair was not considered. Locality properties of more general (but still binary) convolutional codes were recently considered in [14]. However, LRCCs and sliding-window repair as considered in this work were not treated in [14]. Rateless streaming codes (e.g. Fountain codes [5]) are an interesting alternative to MDS block codes for global repair in DSSs (see [20, Ch. 50]), since they generally achive low redundancy and enable global erasure correction with complexity of $\mathcal{O}(k\log(k))$ XOR operations (products in $\mathbb{F}_{2}$) or even less, for $k$ encoded symbols. Locally repairable Fountain codes were proposed in [3]. However, their locality is of order $\log(k)$ (unbounded), for $k$ encoded symbols, and they do not enable sliding-window global repair.

The remainder of the paper is organized as follows. In Section 2, we collect some preliminaries on convolutional codes. In Section 3, we introduce LRCCs and give a Singleton-type bound on their column distances, which determine the sliding-window erasure-correction capability of LRCCs. In Section 4, we show how to obtain LRCCs with arbitrary and small-field local codes and optimal global column distances (in view of the previous bound) based on codes with optimal column sum-rank distances [21]. In Section 5, we introduce partial MDP convolutional codes, whose sliding windows can correct analogous erasure patterns as partial MDS block codes [4, 10]. We also provide concrete constructions of partial MDP convolutional codes based on the codes in [21]. Finally, in Section 6, we discuss extending our work to considering LRCCs with unequal localities and local distances, and how to turn our LRCCs to tail-biting convolutional codes.

2 Preliminaries on Convolutional Codes

In this section, we collect general definitions and results on convolutional codes that we will use throughout the paper.

Let $\mathbb{F}$ be a finite field, and denote by $\mathbb{F}[D]$ the ring of polynomials with coefficients in $\mathbb{F}$. Fix a positive integer $n\in\mathbb{N}$. We will typically consider and graphically represent a word in $\mathbb{F}[D]^{n}$ as an unrestricted sequence of vectors of length $n$, $v(D)=\sum_{j\in\mathbb{N}}v_{j}D^{j}\equiv(v_{0},v_{1},v_{2},\ldots)\in(\mathbb{F}^{n})^{\mathbb{N}}$, where we use the following terminology. A block is each of the $n$ consecutive coordinates in $(\mathbb{F}^{n})^{\mathbb{N}}$ that support each vector $v_{0},v_{1},\ldots$, being the $j$th block the block containing the coordinates supporting $v_{j}$, for $j\in\mathbb{N}$. A symbol is each component of the vectors $v_{0},v_{1},\ldots$, thus it is an element of $\mathbb{F}$. Finally, a node is the abstraction of the storage device that stores a given symbol. Hence, in this work, each block corresponds to $n$ nodes storing $n$ symbols over $\mathbb{F}$.

2.1 Degree and Memory

Recall that, since $\mathbb{F}[D]$ is a principal ideal domain, every $\mathbb{F}[D]$-submodule of $\mathbb{F}[D]^{n}$ is free.

Definition 1**.**

An $(n,k)$ convolutional code is a (free) $\mathbb{F}[D]$-submodule $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ of rank $k$. A generator matrix of the code is a full-rank matrix $G(D)\in\mathbb{F}[D]^{k\times n}$ such that

[TABLE]

For a vector $v(D)\in\mathbb{F}[D]^{n}$, we define its degree as the maximum degree of its components, which are polynomials in $\mathbb{F}[D]$. We say that a generator matrix $G(D)$ of $\mathcal{C}$ is reduced if the sum of the row degrees of $G(D)$ is minimum among generator matrices of $\mathcal{C}$, where by row degrees we mean the degrees of the rows in $G(D)$.

It follows from Theorem A-2, Item 3, in [25] that if $e_{1}\leq e_{2}\leq\ldots\leq e_{k}$ and $f_{1}\leq f_{2}\leq\ldots\leq f_{k}$ are the row degrees of a reduced generator matrix $G(D)\in\mathbb{F}[D]^{k\times n}$ and some other generator matrix $\widetilde{G}(D)\in\mathbb{F}[D]^{k\times n}$, respectively, of $\mathcal{C}$, then $e_{i}\leq f_{i}$, for $i=1,2,\ldots,k$. In particular, the set of degrees $\{e_{1},e_{2},\ldots,e_{k}\}$ of one, thus any, reduced generator matrix is an invariant of the convolutional code $\mathcal{C}$. Hence the following definition is consistent.

Definition 2**.**

Given an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$, let $e_{1},e_{2},\ldots,e_{k}$ be the row degrees of one, thus any, of its reduced generator matrices. We define the degree and memory of $\mathcal{C}$, respectively, as

[TABLE]

Note that convolutional codes with zero memory (thus zero degree) coincide with (potentially infinite) Cartesian products of a single $(n,k)$ block code $\mathcal{C}\subseteq\mathbb{F}^{n}$.

2.2 Non-Catastrophic Codes and Parity-Check Matrices

In most results in this work, although not all, we will require convolutional codes to be non-catastrophic or observable, which we now define in terms of basic generator matrices.

Definition 3**.**

Given an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$, we say that a generator matrix $G(D)$ of $\mathcal{C}$ is basic if it has a polynomial right inverse, that is, if there exists $F(D)\in\mathbb{F}[D]^{n\times k}$ such that $G(D)F(D)=I_{k}$. We say that $\mathcal{C}$ is non-catastrophic if it admits a generator matrix that is reduced and basic.

Observe that any reduced and basic generator matrix $G(D)=\sum_{j=0}^{\mu}G_{j}D^{j}$ of a convolutional code satisfies that $G_{0}\in\mathbb{F}^{k\times n}$ is full-rank. For many results in this work, we will only need this weaker property.

Using Theorem A-1, Item 5, in [25], and using the vector space over $\mathbb{F}(D)$ (the field of fractions of $\mathbb{F}[D]$) generated by a non-catastrophic convolutional code, it is easy to see that it admits a polynomial parity-check matrix. This strong property of non-catastrophic codes is what we will need for sliding-window repair, as described in Subsection 2.4.

Lemma 1**.**

If $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ is a non-catastrophic $(n,k)$ convolutional code, then there exists a full-rank matrix $H(D)\in\mathbb{F}[D]^{(n-k)\times n}$ such that

[TABLE]

We call $H(D)$ a (polynomial) parity-check matrix of $\mathcal{C}$.

2.3 Free and Column Distances

We now recall the main notions of minimum distance of convolutional codes. Given $v(D)=\sum_{j\in\mathbb{N}}v_{j}D^{j}\in\mathbb{F}[D]^{n}$, we define its Hamming weight as

[TABLE]

The free distance, which we now define, gives the correction capability of a convolutional code when considering whole codewords. In other words, there is no maximum degree $j$ for a codeword considered by the free distance.

Definition 4**.**

Given an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$, we define its free distance as

[TABLE]

We next define column distances, which give the sliding-window correction capability of a non-catastrophic convolutional code (see the next subsection). This will be the type of distance that we will be interested in for global repair in our locally repairable codes.

Definition 5**.**

Given an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$, with memory $\mu$ and reduced generator matrix $G(D)=\sum_{h=0}^{\mu}G_{h}D^{h}$, define the $j$th truncated sliding generator matrix $G_{j}^{c}\in\mathbb{F}^{(j+1)k\times(j+1)n}$ as

[TABLE]

for $j\in\mathbb{N}$, where $G_{h}=0$ if $h>\mu$. Define now the $j$th column block code of $\mathcal{C}$ as

[TABLE]

where the equality $*$ holds if $G_{0}$ is full-rank. Finally, define the $j$th column distance of $\mathcal{C}$ as

[TABLE]

where note that $v\neq 0$ if $v\in\mathcal{C}_{j}^{c}$, for $j\in\mathbb{N}$.

The column distances satisfy the following Singleton bound, which was proven in [9, Prop. 2.2].

Proposition 1** ([9]).**

For an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ with a generator matrix $G(D)=\sum_{j=0}^{\mu}G_{j}D^{j}$ (possibly not reduced) such that $G_{0}$ is full-rank, and for $j\in\mathbb{N}$, it holds that

[TABLE]

Items 1 and 2 in the following proposition follow from [9, Cor. 2.3] and [30, Th. 2.2], respectively.

Proposition 2** ([9, 30]).**

Given a non-catastrophic $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ of degree $\delta$, the following hold:

If $\operatorname{d}_{j+1}^{c}(\mathcal{C})=(n-k)(j+2)+1$, then $\operatorname{d}_{j}^{c}(\mathcal{C})=(n-k)(j+1)+1$. 2. 2.

If $\operatorname{d}_{j}^{c}(\mathcal{C})=(n-k)(j+1)+1$, then

[TABLE]

The previous proposition motivates the following definition.

Definition 6**.**

We say that an $(n,k)$ convolutional code $\mathcal{C}$ is $j$-MDS if it is non-catastrophic and $\operatorname{d}_{j}^{c}(\mathcal{C})=(n-k)(j+1)+1$. We say that $\mathcal{C}$ is maximum distance profile (MDP) if it is non-catastrophic and $\operatorname{d}_{L}^{c}(\mathcal{C})=(n-k)(L+1)+1$, where $L$ is as in (2).

2.4 Sliding-Window (Global) Repair

As shown in [33, Th. 3.1] and its proof, a non-catastrophic $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ may correct any erasure pattern with up to $\operatorname{d}^{c}_{j}(\mathcal{C})-1$ erasures in any tuple $(v_{t},v_{t+1},\ldots,v_{t+j})\in\mathbb{F}^{n(j+1)}$, for $j\in\mathbb{N}$. Furthermore, it may do so recursively by sliding a window that only involves the symbols in $v_{t-\mu},v_{t-\mu+1},\ldots,v_{t+j}$, where $\mu=\mu(\mathcal{C})$. The formal statement is as follows. See also Fig. 2 for a graphical description.

For convenience, we first define erasures formally.

Definition 7**.**

Let $\star$ be a symbol not belonging to any finite field, and denote $\widetilde{\mathbb{F}}=\mathbb{F}\cup\{\star\}$. Given $N\in\mathbb{N}$ and $v\in\mathbb{F}^{N}$, we say that $v^{*}\in\widetilde{\mathbb{F}}^{N}$ is the vector $v$ with $e$ erasures, where $0\leq e\leq N$, if $e$ components of $v^{*}$ are the symbol $\star$, and $v$ and $v^{*}$ coincide in the other $N-e$ components.

We now state [33, Th. 3.1] and part of its proof.

Theorem 1** ([33]).**

Let $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ be a non-catastrophic $(n,k)$ convolutional code with memory $\mu$, and fix $j\in\mathbb{N}$. Let $v(D)=\sum_{h\in\mathbb{N}}v_{h}D^{h}\in\mathcal{C}$ and let $v^{*}_{0},v^{*}_{1},v^{*}_{2},\ldots\in\widetilde{\mathbb{F}}^{n}$ be such that $(v_{t}^{*},v_{t+1}^{*},\ldots,v_{t+j}^{*})\in\widetilde{\mathbb{F}}^{n(j+1)}$ is the vector $(v_{t},v_{t+1},\ldots,v_{t+j})\in\mathbb{F}^{n(j+1)}$ with at most $\operatorname{d}^{c}_{j}(\mathcal{C})-1$ erasures, for all $t\in\mathbb{N}$. Then, for each $t=0,1,2,\ldots$, the vector $v_{t}\in\mathbb{F}^{n}$ can be recursively and uniquely recovered from the tuple

[TABLE]

by solving a system of non-homogeneous equations, whose coefficients are given by a parity-check matrix of $\mathcal{C}$ (Lemma 1), the symbols in $v_{t-\mu},v_{t-\mu+1},\ldots,v_{t-1}$, and the symbols such that $v_{u,i}^{*}=v_{u,i}$, for $u=t,t+1,\ldots,t+j$, and whose unknowns are $x_{u,i}$, for $i$ such that $v_{u,i}^{*}=\star$, for $u=t,t+1,\ldots,t+j$. To recover $v_{t+1}$, we “slide” the window (3) one position to the right (see Fig. 2).

In the previous theorem, we implicitly assume that $v_{j}=0$ for all $j=-1,-2,\ldots,-\mu$.

This type of erasure correction may already be considered as local repair, since $j$ may be small. Furthermore, the window size is not necessarily restricted, since $j$ may be arbitrary. However, setting $j=0$, we see that correcting one erasure in a single block $v_{t}\in\mathbb{F}^{n}$ requires contacting another $\mu n$ nodes and downloading their symbols, corresponding to $(v_{t-\mu},v_{t-\mu+1},\ldots,v_{t-1})\in\mathbb{F}^{\mu n}$, in order to set up the necessary system of linear equations. Thus, although sliding-window repair enjoys certain local nature, it admits considerable room for improvement. Adding locality inside each block $v_{t}$ optimally will be our main objective in the rest of the paper.

3 Locality in Convolutional Codes

In this section, we formulate locality for convolutional codes. For this purpose, we define the following two types of restrictions for a convolutional code. The first type consists in considering one generic block $v_{j}\in\mathbb{F}^{n}$ for arbitrary codewords $v(D)$ in the convolutional code.

Definition 8**.**

Given an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ with reduced generator matrix $G(D)=\sum_{j=0}^{\mu}G_{j}D^{j}$, where $\mu$ is the memory of the code, we define its associated block code as

[TABLE]

Note that by the second equality, the definition of $\mathcal{C}^{0}$ does not depend on the generator matrix of $\mathcal{C}$. We now give the second type of restriction, which consists in restricting each block of the convolutional code to some subset of coordinates $\Gamma\subseteq[n]$. Here, we use the notation $[n]=\{1,2,\ldots,n\}$.

Definition 9**.**

Given an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ and given a non-empty subset $\Gamma\subseteq[n]$, we define the restriction of $\mathcal{C}$ to $\Gamma$ as the convolutional code

[TABLE]

Here, if $v\in\mathbb{F}^{n}$, then $v_{\Gamma}\in\mathbb{F}^{|\Gamma|}$ denotes the projection of $v$ onto the coordinates in $\Gamma$. Then if $v(D)=\sum_{j\in\mathbb{N}}v_{j}D^{j}\in\mathbb{F}[D]^{n}$, we use the notation $v(D)_{\Gamma}=\sum_{j\in\mathbb{N}}(v_{j})_{\Gamma}D^{j}\in\mathbb{F}[D]^{|\Gamma|}$.

For a matrix $G(D)\in\mathbb{F}[D]^{k\times n}$, we denote by $G(D)_{\Gamma}\in\mathbb{F}[D]^{k\times|\Gamma|}$ the matrix whose rows are the rows of $G(D)$ restricted to $\Gamma$.

Observe that if $G(D)\in\mathbb{F}[D]^{k\times n}$ is a generator matrix of $\mathcal{C}$, then the rows of $G(D)_{\Gamma}\in\mathbb{F}^{k\times|\Gamma|}$ generate $\mathcal{C}_{\Gamma}$, although they may not be $\mathbb{F}[D]$-linearly independent.

We may now extend the definition of $(r,\partial)$-locality for block codes from [16, Def. 1] to convolutional codes.

Definition 10**.**

We say that an $(n,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ has $(r,\partial)$-locality if there exist non-empty sets $\Gamma_{i}$, for $i=1,2,\ldots,g$, such that $[n]=\bigcup_{i=1}^{g}\Gamma_{i}$, and

$|\Gamma_{i}|\leq r+\partial-1$, 2. 2.

$\operatorname{d}(\mathcal{C}_{\Gamma_{i}}^{0})\geq\partial$,

for $i=1,2,\ldots,g$. Here, we write $\mathcal{C}_{\Gamma_{i}}^{0}$ instead of $(\mathcal{C}_{\Gamma_{i}})^{0}=(\mathcal{C}^{0})_{\Gamma_{i}}$ for simplicity. Thus, $\mathcal{C}_{\Gamma_{i}}^{0}$ denotes the block code associated (Definition 8) to the restriction (Definition 9) of $\mathcal{C}$ on $\Gamma_{i}$.

We say then that $\mathcal{C}$ is an $(n,k,r,\partial)$* locally repairable convolutional code*, or LRCC for short. The set $\Gamma_{i}$ is called the $i$th local group, for $i=1,2,\ldots,g$, and $r$ and $\partial$ are called the locality and local distance of $\mathcal{C}$, respectively.

In other words, we consider local groups in each block of $n$ symbols, corresponding to terms $v_{j}\in\mathbb{F}^{n}$ in a codeword $v(D)=\sum_{j\in\mathbb{N}}v_{j}D^{j}\in\mathcal{C}$. See Fig. 3 for a graphical example of a $(6,3,2,2)$ LRCC with $2$ local groups. In contrast to block codes, local repair with only one local group ($g=1$) per block already outperforms sliding-window repair even when $j=0$, in terms of total contacted nodes, see Fig. 4.

We state now the local erasure-correction capability of LRCCs. Definition 10 is given so that the following result holds. The proof is straightforward.

Proposition 3**.**

Let $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ be an $(n,k,r,\partial)$ LRCC with local groups $\Gamma_{i}$, for $i=1,2,\ldots,g$. Fix $j\in\mathbb{N}$ and $i=1,2,\ldots,g$. For all $v(D)=\sum_{j\in\mathbb{N}}v_{j}D^{j}\in\mathcal{C}$, if $v^{*}\in\widetilde{\mathbb{F}}^{|\Gamma_{i}|}$ is the vector $(v_{j})_{\Gamma_{i}}\in\mathbb{F}^{|\Gamma_{i}|}$ with at most $\partial-1$ erasures (see Definition 7), then we may uniquely recover the vector $(v_{j})_{\Gamma_{i}}$ from $v^{*}$ by using the restricted block code $\mathcal{C}_{\Gamma_{i}}^{0}\subseteq\mathbb{F}^{|\Gamma_{i}|}$, without contacting nodes or reading symbols outside of $\Gamma_{i}$ in the $j$th block of the convolutional code.

As it was the case for locally repairable block codes, the main goal, given the parameters $n$, $k$, $r$ and $\partial$ (and now also $\delta$ and $\mu$), is to obtain a corresponding LRCC with maximum global distance properties, which would allow for global erasure correction in case of catastrophic failures. In this work, we consider column distances for “global correction”, since we will focus on sliding-window erasure correction as in Theorem 1. See Fig. 4 for a graphical description of local repair combined with sliding-window global repair.

In the next theorem, we provide a Singleton bound on column distances of LRCCs. As the reader can see, we need to make three assumptions for the general bound, the first being that local groups are pair-wise disjoint and of full length, the second being that $r$ divides $k$, and the third is that a smallest possible subset of local groups form an information set of the code. This latter condition is satisfied if the [math]th column distance is optimal, as stated in the theorem.

Theorem 2**.**

Let $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ be an $(n,k,r,\partial)$ LRCC with a reduced generator matrix $G(D)=\sum_{h=0}^{\mu}G_{h}D^{h}$ such that $G_{0}$ is full-rank. Then it holds that

[TABLE]

Now assume that $k=\ell r$, for a positive integer $\ell$, local groups are pair-wise disjoint (i.e., $\Gamma_{i}\cap\Gamma_{j}=\varnothing$ if $i\neq j$) and of full size $r+\partial-1$, and that there exist $\ell$ of them forming an information set for the $k$-dimensional linear block code $\mathcal{C}_{0}^{c}\cup\{0\}\subseteq\mathbb{F}^{n}$, generated by $G_{0}$. This latter condition holds if equality is achieved in (4), by Lemma 7 in Appendix A. Then it holds that

[TABLE]

for all $j\in\mathbb{N}$.

Proof.

We start by observing that $G_{0}^{c}=G_{0}$ and the block code

[TABLE]

is a $k$-dimensional linear block LRC of length $n$ with $(r,\partial)$-localities. Hence the bound (4) is the classical upper bound on the minimum Hamming distance of linear block LRCs [16, Th. 2.1].

We will now prove the bound (5), for $j\in\mathbb{N}$, given the assumptions in the theorem. Assume that local groups are pair-wise disjoint, and that $|\Gamma_{i}|=r+\partial-1$, for $i=1,2,\ldots,g$. Finally, assume, without loss of generality, that the first $\ell$ local groups $\Gamma_{1},\Gamma_{2},\ldots,\Gamma_{\ell}$ form an information set for the linear block code $\mathcal{C}_{0}=\mathcal{C}_{0}^{c}\cup\{0\}$.

Let $\Delta_{i}\subseteq\Gamma_{i}$ denote the first $r$ coordinates in $\Gamma_{i}$, for $i=1,2,\ldots,g$. By the $(r,\partial)$-locality of $\mathcal{C}_{0}$, the set

[TABLE]

is an information set of $\mathcal{C}_{0}$ of size $k=\ell r$. Hence we may perform row operations on the generator matrix $G_{0}\in\mathbb{F}^{k\times n}$ of $\mathcal{C}_{0}$ to obtain a systematic generator matrix of the form

[TABLE]

for matrices $A_{0,1},A_{0,2},\ldots,$ $A_{0,\ell}\in\mathbb{F}^{k\times(\partial-1)}$ and $B_{0,1},B_{0,2},\ldots,$ $B_{0,g-\ell}\in\mathbb{F}^{k\times(r+\partial-1)}$, and where $I_{r,1},I_{r,2},\ldots,$ $I_{r,\ell}\in\mathbb{F}^{k\times r}$ are such that

[TABLE]

is the $k\times k$ identity matrix.

Fix now $j\in\mathbb{N}$. Using the systematic generator matrix of $\mathcal{C}_{0}$ from (7), we may perform row operations on the $j$th truncated sliding generator matrix $G_{j}^{c}\in\mathbb{F}^{(j+1)k\times(j+1)n}$ from Definition 5 to obtain a row equivalent matrix (i.e., a matrix with the same row space) of the form

[TABLE]

such that

[TABLE]

for matrices $A_{h,1},A_{h,2},\ldots,$ $A_{h,\ell}\in\mathbb{F}^{k\times(\partial-1)}$ and $B_{h,1},B_{h,2},\ldots,$ $B_{h,g-\ell}\in\mathbb{F}^{k\times(r+\partial-1)}$, for $h=1,2,\ldots,j$, and where $0_{k,r}\in\mathbb{F}^{k\times r}$ denotes the $k\times r$ zero matrix.

Now, let $v=(v_{0},v_{1},\ldots,v_{j})\in\mathbb{F}^{(j+1)n}$ be the first row of the matrix $\widetilde{G}_{j}^{c}\in\mathbb{F}^{(j+1)k\times(j+1)n}$ from (8). By (9), we have that

[TABLE]

for vectors $a_{h,1},a_{h,2},\ldots,$ $a_{h,\ell}\in\mathbb{F}^{\partial-1}$, $b_{h,1},b_{h,2},\ldots,b_{h,g-\ell}\in\mathbb{F}^{r+\partial-1}$, and where $0_{r}\in\mathbb{F}^{r}$ denotes the zero vector of length $r$.

Clearly $v\in\mathcal{C}_{j}^{c}$, since it is a linear combination of rows of the matrix $G_{j}^{c}$ from Definition 5, and its first block of $n$ components is nonzero, that is, $v_{0}\neq 0$.

Finally, since $\mathcal{C}$ is an LRCC, by Item 2 in Definition 10, we deduce that

[TABLE]

where $0_{\partial-1}\in\mathbb{F}^{\partial-1}$ is the zero vector of length $\partial-1$.

Therefore, we conclude that

[TABLE]

and we are done. ∎

In the next section, we show how to explicitly construct a non-catastrophic LRCC attaining the previous bound, for all $j=0,1,2,\ldots,L$, where $L$ is as in (2), for fields of any characteristic but sufficiently large.

Remark 1**.**

Recall that, by Proposition 2, a convolutional code that is $j$-MDS is also $h$-MDS, for all $h=0,1,2,\ldots,j$. However, it is not clear whether a code attaining the bound (5) for some $j$ implies attaining the bound for $h<j$. We leave this as an open problem. In any case, Construction 1 below based on a $j$-MSRD convolutional code attains the bound (5) for all $h=0,1,2,\ldots,j$.

4 LRCCs based on Sum-Rank Convolutional Codes

In this section, we will show how to construct non-catastrophic LRCCs attaining the bound in Theorem 2, for $j=0,1,\ldots,L$, using a $j$-MSRD convolutional code (see Definition 13 below). To that end, we will use the notion of sum-rank weight on each block of a convolutional code. Sum-rank weights were first defined in [28] for error correction in multishot network coding (see also [21, 22, 23, 26, 34] and the references therein). They were implicitly considered earlier in the space-time coding literature (see [19, Sec. III]), and they have been first used for locally repairable block codes in [24].

Throughout this section, we will fix a prime power $q$ and a positive integer $m$, and we will assume that $\mathbb{F}=\mathbb{F}_{q^{m}}$. Fix an ordered basis $\mathcal{A}=\{\alpha_{1},\alpha_{2},\ldots,\alpha_{m}\}$ of $\mathbb{F}_{q^{m}}$ over $\mathbb{F}_{q}$. For any positive integer $s$, we denote by $M_{\mathcal{A}}:\mathbb{F}_{q^{m}}^{s}\longrightarrow\mathbb{F}_{q}^{m\times s}$ the corresponding matrix representation map, given by

[TABLE]

where $c=\sum_{i=1}^{m}\alpha_{i}(c_{i,1},c_{i,2},\ldots,c_{i,s})\in\mathbb{F}_{q^{m}}^{s}$ and $c_{i,j}\in\mathbb{F}_{q}$, for $i=1,2,\ldots,m$ and $j=1,2,\ldots,s$.

Throughout this section, we will also fix a number of local groups $g$, a locality $r$, and the sum-rank length decomposition $N=gr$. The following definition is given in [28].

Definition 11** ([28]).**

Let $c=(c^{(1)},$ $c^{(2)},$ $\ldots,$ $c^{(g)})\in\mathbb{F}_{q^{m}}^{N}$, where $c^{(i)}\in\mathbb{F}_{q^{m}}^{r}$, for $i=1,2,\ldots,g$. We define the sum-rank weight of $c$ as

[TABLE]

We extend sum-rank weights to convolutional codes as follows.

Definition 12**.**

Given $v(D)=\sum_{j\in\mathbb{N}}v_{j}D^{j}\in\mathbb{F}_{q^{m}}[D]^{N}$, we define its sum-rank weight as

[TABLE]

Given an $(N,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$, we define its sum-rank free distance as

[TABLE]

Finally, we define the $j$th sum-rank column distance of $\mathcal{C}$ as

[TABLE]

where $\mathcal{C}_{j}^{c}$ is as in Definition 5, in particular $v\neq 0$ if $v\in\mathcal{C}_{j}^{c}$, for $j\in\mathbb{N}$.

Observe that, for any $c=(c^{(1)},c^{(2)},\ldots,c^{(g)})\in\mathbb{F}_{q^{m}}^{N}$, where $c^{(i)}\in\mathbb{F}_{q^{m}}^{r}$, for $i=1,2,\ldots,g$, it holds that

[TABLE]

since the rank of a matrix is at most the number of its non-zero columns. Hence, the following result follows immediately from its Hamming-metric counterpart (Propositions 1 and 2).

Proposition 4**.**

Given a non-catastrophic $(N,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$, it holds that

[TABLE]

for all $j\in\mathbb{N}$. Furthermore, the following hold.

If $\operatorname{d}_{SR,j+1}^{c}(\mathcal{C})=(N-k)(j+2)+1$, then $\operatorname{d}_{SR,j}^{c}(\mathcal{C})=(N-k)(j+1)+1$, for $j\in\mathbb{N}$. 2. 2.

If $\operatorname{d}_{SR,j}^{c}(\mathcal{C})=(N-k)(j+1)+1$, then $j\leq L$, where $L$ is as in (2).

The previous proposition motivates the following definition.

Definition 13**.**

We say that an $(N,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$ is $j$-maximum-sum-rank-distance, or $j$-MSRD for short, if it is non-catastrophic and $\operatorname{d}_{SR,j}^{c}(\mathcal{C})=(N-k)(j+1)+1$.

We now describe how to construct LRCCs from sum-rank convolutional codes. This construction is inspired by [29, Const. I].

Construction 1**.**

Assume that $q\geq r+\partial-1$, and choose:

Outer code: An $(N,k)$ convolutional code $\mathcal{C}_{out}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$. 2. 2.

Local codes: An MDS $(r+\partial-1,r)$ block code $\mathcal{C}_{loc}\subseteq\mathbb{F}_{q}^{r+\partial-1}$ with generator matrix $A\in\mathbb{F}_{q}^{r\times(r+\partial-1)}$. 3. 3.

Global code: We define the global code $\mathcal{C}_{glob}\subseteq\mathbb{F}_{q^{m}}[D]^{n}$, with $n=(r+\partial-1)g=N+(\partial-1)g$, as the $(n,k)$ convolutional code given by

[TABLE]

where $\operatorname{Diag}_{g}(A)$ is defined as a block-diagonal matrix with $A\in\mathbb{F}_{q}^{r\times(r+\partial-1)}$ repeated $g$ times (recall that $N=gr$ and $n=g(r+\partial-1)$):

[TABLE]

Observe that if $G_{out}(D)=\sum_{j=0}^{\mu}G_{out,j}D^{j}\in\mathbb{F}_{q^{m}}[D]^{k\times N}$ is a generator matrix of $\mathcal{C}_{out}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$, then a generator matrix of $\mathcal{C}_{glob}\subseteq\mathbb{F}_{q^{m}}[D]^{n}$ is simply given by

[TABLE]

In addition, note that multiplying a vector $v(D)\in\mathbb{F}[D]^{N}$ on the right by a rank-$N$ constant matrix $C\in\mathbb{F}^{N\times n}$ preserves the degree of $v(D)$. Hence if $G_{out}(D)$ is reduced, then so is $G_{glob}(D)$. It also follows easily that if $G_{out}(D)$ is basic, then so is $G_{glob}(D)$. Thus we deduce the following.

Lemma 2**.**

In Construction 1, if $\mathcal{C}_{out}$ is non-catastrophic, then so are $\mathcal{C}_{glob}$ and $(\mathcal{C}_{glob})_{\Delta}$, for any $\Delta=\bigcup_{i=1}^{g}\Delta_{i}\subseteq[n]$ such that $\Delta_{i}\subseteq\Gamma_{i}$ and $|\Delta_{i}|\geq r$, for $i=1,2,\ldots,g$. Here, we denote $\Gamma_{i}=[(r+\partial-1)(i-1)+1,(r+\partial-1)i]\subseteq[n]$, for $i=1,2,\ldots,g$.

As it was the case for locally repairable block codes (see [24, Lemma 1]), any LRCC whose local codes are all encoded by the same linear MDS code over the subfield $\mathbb{F}_{q}$, are necessarily of the form of Construction 1. For this reason, Construction 1 not only is natural, but it is somehow unavoidable.

We may now prove the main result of this section, which states that $\mathcal{C}_{glob}$ in Construction 1 has maximum $h$th sum-rank column distance among all non-catastrophic $(n,k,r,\partial)$ LRCC, for $h=0,1,2,\ldots,j$, if $\mathcal{C}_{out}$ is $j$-MSRD.

Theorem 3**.**

In Construction 1, $\mathcal{C}_{glob}$ is an $(n,k,r,\partial)$ LRCC. Furthermore, if $j\in\mathbb{N}$ and $\mathcal{C}_{out}$ is $j$-MSRD (thus non-catastrophic), then $\mathcal{C}_{glob}$ is non-catastrophic and

[TABLE]

for all $h=0,1,2,\ldots,j$.

Proof.

First, it follows easily from the definitions and Construction 1 that $\mathcal{C}_{glob}$ is an $(n,k,r,\partial)$ LRCC. The non-catastrophic property is part of Lemma 2. Therefore, we only need to show that (12) holds for $h=j$, since if $\mathcal{C}_{out}$ is $j$-MSRD, then $\mathcal{C}_{out}$ is $h$-MSRD, for all $h=0,1,2,\ldots,j$, by Proposition 4.

Now we need to show that, for any $v\in(\mathcal{C}_{glob})_{j}^{c}\subseteq\mathbb{F}_{q^{m}}^{n(j+1)}$, the non-zero coordinates of $v$ are not all inside some pattern of

[TABLE]

erasures in the block $[n(j+1)]$ of coordinates.

Assume the opposite holds, that is, there exists $v\in(\mathcal{C}_{glob})_{j}^{c}$ with all of its non-zero coordinates in an erasure pattern of size $e$. Observe that $v\in\mathbb{F}_{q^{m}}^{n(j+1)}$ is a block codeword, and by construction, there exists $x\in(\mathcal{C}_{out})_{j}^{c}$ such that $v=x\operatorname{Diag}_{g(j+1)}(A)$.

Let $\mathcal{E}_{gh+i}\subseteq[r+\partial-1]$ be the erasure pattern in the $i$th local group in the $h$th block of $n$ coordinates, and define $\mathcal{R}_{gh+i}=[r+\partial-1]\setminus\mathcal{E}_{gh+i}$, for $i=1,2,\ldots,g$ and $h=0,1,2,\ldots,j$. The truncated global codeword after removing all the symbols in such an erasure pattern is by assumption the zero vector, that is,

[TABLE]

where $e=\sum_{u=1}^{g(j+1)}|\mathcal{E}_{u}|=n(j+1)-\sum_{u=1}^{g(j+1)}|\mathcal{R}_{u}|$.

Assume for simplicity that $k(j+1)=\ell r$, for some integer $\ell\in\mathbb{N}$. Note that we may decompose

[TABLE]

As discussed in the proof of [29, Th. 24], the best-case erasure pattern is obtained when erasures concentrate in the smallest number of local groups. Here, by best-case erasure pattern we mean an erasure pattern whose complement set of coordinates contain the most locally redundant symbols, which means that $\sum_{u=1}^{g(j+1)}\operatorname{Rk}(A|_{\mathcal{R}_{u}})$ is the minimum possible. Thus by (14), in the best case we have without loss of generality that $\mathcal{R}_{u}=[r+\partial-1]$, for $u=1,2,\ldots,\ell-1$, $|\mathcal{R}_{\ell}|=r$, and $\mathcal{R}_{u}=\varnothing$, for $u=\ell+1,\ell+2,\ldots,g(j+1)$. Since $\mathcal{C}_{loc}$ is an $(r+\partial-1,r)$ MDS code, we have that $\operatorname{Rk}(A|_{\mathcal{R}_{u}})=r$, for $u=1,2,\ldots,\ell$. Therefore, in the best case, we have that

[TABLE]

Define now $\mathcal{R}^{\prime}_{u}\subseteq[r+\partial-1]$ as the set formed by some $r$ coordinates in $\mathcal{R}_{u}\subseteq[r+\partial-1]$, for $u=1,2,\ldots,\ell$. Define also $\mathcal{R}^{\prime}_{u}\subseteq[r+\partial-1]$ as any $r$ coordinates in $[r+\partial-1]$, for $u=\ell+1,\ell+2,\ldots,g(j+1)$. Since $\mathcal{C}_{loc}$ is an $(r+\partial-1,r)$ MDS code, we have that ${\rm Rk}(A|_{\mathcal{R}^{\prime}_{u}})=r$, that is, $A|_{\mathcal{R}^{\prime}_{u}}\in\mathbb{F}_{q}^{r\times r}$ is invertible, for $u=1,2,\ldots,g(j+1)$. Therefore, we conclude that

[TABLE]

where the last inequality follows from (13). This is absurd since $x\in(\mathcal{C}_{out})_{j}^{c}$ and

[TABLE]

We conclude that there is no $v\in(\mathcal{C}_{glob})_{j}^{c}$ whose non-zero coordinates are all inside some pattern of $e$ erasures, hence $\operatorname{d}_{SR,j}^{c}(\mathcal{C}_{glob})\geq e+1$, and we are done. ∎

We conclude by plugging in Construction 1 the MSRD convolutional codes from [21] (see Appendix B) as outer codes, and applying the previous theorem.

Corollary 1**.**

If $N=gr$, $(N-k)|\delta$, $M=\max\{N-k,k\}$, $L=\lfloor\frac{\delta}{k}\rfloor+\delta/(N-k)$, $q\geq r+\partial-1$ and $m\geq q^{M(L+2)-1}$, then there exists a non-catastrophic $(n,k,r,\partial)$ LRCC $\mathcal{C}_{glob}\subseteq\mathbb{F}_{q^{m}}[D]^{n}$, of degree $\delta$, satisfying (5) with equality, for $j=0,1,2,\ldots,L$, given as in Construction 1, and where $\mathcal{C}_{out}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$ is the non-catastrophic $L$-MSRD convolutional code in Appendix B.

Corollary 1 not only shows that the upper bound given in (5) is sharp, but also provides an explicit class of codes that achieves such a bound. Moreover, these codes exist for any characteristic (in particular, when $2|q$), and the local code may be arbitrary and with local fields of size $q\approx r+\partial-1$, which are small. We may also choose $q=2$ if $\partial=2$ and local repair would simply consist in XORing. Their main disadvantage is the huge exponent $m$, which is in turn exponential in the degree $\delta$ and in $\max\{N-k,k\}$. However, the bound on $m$ in the corollary is only a bound, and there are cases when $m$ can be chosen much smaller (see Table I in [21]).

5 Partial $j$-MDS and Partial MDP Convolutional Codes

In this section, we introduce partial MDP convolutional codes, analogous to the concept of partial MDS codes, or LRC with maximal recoverability (MR), introduced in [4, 10]. We will conclude by showing that the codes in Corollary 1 are partial MDP.

Definition 14**.**

With notation as in Definition 10, and for $j\in\mathbb{N}$, we say that an $(n,k,r,\partial)$ LRCC $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ is partial $j$-MDS if the following holds: For all $\Delta_{i}\subseteq\Gamma_{i}$ such that $|\Gamma_{i}\setminus\Delta_{i}|=\partial-1$, for $i=1,2,\ldots,g$, the restricted $(N,k)$ convolutional code $\mathcal{C}_{\Delta}\subseteq\mathbb{F}[D]^{N}$ is non-catastrophic and $j$-MDS (Definition 6), where $\Delta=\bigcup_{i=1}^{g}\Delta_{i}$ and $N=|\Delta|$.

Some explanations about Definition 14 are in order.

First, we observe that the restricted convolutional code $\mathcal{C}_{\Delta}\subseteq\mathbb{F}[D]^{N}$ in the previous definition has rank $k$ by Lemma 3 below, thus the definition is consistent.

Lemma 3**.**

Let $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ be an $(n,k,r,\partial)$ LRCC with local groups $\Gamma_{i}$, for $i=1,2,\ldots,g$, as in Definition 10. Let $\Delta_{i}\subseteq\Gamma_{i}$ be such that $|\Gamma_{i}\setminus\Delta_{i}|\leq\partial-1$, for $i=1,2,\ldots,g$, and define $\Delta=\bigcup_{i=1}^{g}\Delta_{i}$ and $N=|\Delta|$. Then the restricted code $\mathcal{C}_{\Delta}\subseteq\mathbb{F}[D]^{N}$ has rank $k$, or in other words, it is an $(N,k)$ convolutional code.

In addition, if $G(D)=\sum_{j=0}^{\mu}G_{j}D^{j}$ is a reduced generator matrix of $\mathcal{C}$ such that $G_{0}$ is full-rank, then $(G_{0})_{\Delta}$ is also full-rank.

Proof.

Let $G(D)\in\mathbb{F}[D]^{k\times n}$ be a generator matrix of $\mathcal{C}$. It suffices to prove that the rows of $G(D)_{\Delta}\in\mathbb{F}[D]^{k\times N}$ are $\mathbb{F}[D]$-linearly independent.

Assume that there exists $x(D)\in\mathbb{F}[D]^{k}$ such that $x(D)G(D)_{\Delta}=0$. If $v(D)=x(D)G(D)\in\mathcal{C}$, then we have that $v(D)_{\Delta}=x(D)G(D)_{\Delta}=0$. Write $v(D)=\sum_{j\in\mathbb{N}}v_{j}D^{j}$ and fix $j\in\mathbb{N}$. We then deduce that $(v_{j})_{\Delta}=0$, and therefore $(v_{j})_{\Delta_{i}}=0$, for $i=1,2,\ldots,g$. Since $\operatorname{d}(\mathcal{C}_{\Gamma_{i}}^{0})\geq\partial$ and $|\Gamma_{i}\setminus\Delta_{i}|\leq\partial-1$, we deduce that $(v_{j})_{\Gamma_{i}}=0$, for $i=1,2,\ldots,g$. Now, because $[n]=\bigcup_{i=1}^{g}\Gamma_{i}$, we conclude that $v_{j}=0$.

Thus we have proven that $x(D)G(D)=0$. Since $G(D)$ has full rank, we conclude that $x(D)=0$, and we are done. The statement regarding $G_{0}$ and $(G_{0})_{\Delta}$ is proven following the same lines. ∎

Similar to the case of block codes (replacing $j$-MDS by MDS), the term partial $j$-MDS is motivated by the fact that the column distances attain the bound (5) (see Proposition 5 below), thus they have smaller column distances than those of $j$-MDS codes (this is the price to pay for locality). However, partial $j$-MDS codes as in Definition 14 can be seen as $j$-MDS codes that can be added locality in some optimal sense: We can recover some other $j$-MDS code after removing any (maximal) collection of local parities, not only the added ones. Due to this reason, we gain a considerable flexibility in the erasure patterns that can be corrected (see Fig. 5).

In the block case, partial MDS codes can be equivalently defined as follows: A locally repairable block code is partial MDS if it can correct all erasure patterns that are information-theoretically correctable for the given local constraints $r$ and $\partial$ and the given dimension $k$ and length $n$. Obviously, if there are no local constraints ($\partial=1$ for instance), then being able to correct all information-theoretically correctable erasure patterns is equivalent to being MDS.

See Fig. 5 for a graphical description of sliding-window repair combined with local repair in a partial $j$-MDS convolutional code.

We now show that partial $j$-MDS codes attain the bound (5), hence being optimal LRCCs in terms of column distances. We need a preliminary lemma, which is of interest by itself and which follows directly from Definition 14 and Proposition 2.

Lemma 4**.**

If an LRCC is partial $j$-MDS, then it is partial $h$-MDS, for all $h=0,1,2,\ldots,j$.

Proposition 5**.**

If an $(n,k,r,\partial)$ LRCC is partial $j$-MDS for some $j\in\mathbb{N}$, then its column distances attain the bound (5), for all $h=0,1,2,\ldots,j$.

Proof.

By the previous lemma, we only need to prove the result for $h=j$. For such a case, the proof follows exactly the same lines as the proof of Theorem 3, and is left to the reader. ∎

Remark 2**.**

In the block case, the converse is not true. For instance, Tamo-Barg codes [32] are locally repairable codes with optimal global distance, but cannot always be maximally recoverable (partial MDS) by the field-size bound in [12, Eq. (2)]. We conjecture, but do not prove or disprove, that not every LRCC attaining the bound (5), for some $j\in\mathbb{N}$, is a partial $j$-MDS convolutional code.

Our next goal is to define partial MDP convolutional codes, which are partial $j$-MDS for the maximum value of $j$. We first need the following lemma, which follows directly from the definitions and Proposition 2.

Lemma 5**.**

Let $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ be an $(n,k)$ convolutional code. For any $\Delta\subseteq[n]$, it holds that

[TABLE]

In particular, if $\mathcal{C}_{\Delta}$ is $j$-MDS, then $j\leq\left\lfloor\frac{\delta}{k}\right\rfloor+\left\lfloor\frac{\delta}{N-k}\right\rfloor$, for $N=|\Delta|$ and $\delta=\delta(\mathcal{C})$.

We may now define partial MDP convolutional codes.

Definition 15**.**

We say that an $(n,k,r,\partial)$ LRCC $\mathcal{C}\subseteq\mathbb{F}[D]^{n}$ is partial MDP if it is partial $L$-MDS for $L=\lfloor\frac{\delta}{k}\rfloor+\lfloor\frac{\delta}{N-k}\rfloor$, where $N=n-g(\partial-1)$ and $\delta=\delta(\mathcal{C})$.

The main purpose of this section is to show that the global code in Construction 1 based on an MSRD outer code (for instance, that in Appendix B) is partial MDP. In particular, we will show the existence of partial MDP codes for general parameters, over any characteristic, for sufficiently large fields.

We first need the following lemma, which is [24, Th. 1]. Observe that we will make use of this lemma in the non-linear case.

Lemma 6** ([24]).**

Recall that $N=gr$. Given a (linear or non-linear) block code $\mathcal{C}\subseteq\mathbb{F}_{q^{m}}^{N}$, it holds that

[TABLE]

We may now prove the main result of this section.

Theorem 4**.**

In Construction 1, the following hold:

If $j\in\mathbb{N}$ and $\mathcal{C}_{out}$ is non-catastrophic and $j$-MSRD, then $\mathcal{C}_{glob}$ is partial $j$-MDS. 2. 2.

$\delta(\mathcal{C}_{glob})=\delta(\mathcal{C}_{out})$* and $\mu(\mathcal{C}_{glob})=\mu(\mathcal{C}_{out})$.* 3. 3.

If $\mathcal{C}_{out}$ is non-catastrophic and $L$-MSRD, where $L=\lfloor\frac{\delta}{k}\rfloor+\lfloor\frac{\delta}{N-k}\rfloor$ and $\delta=\delta(\mathcal{C}_{out})$, then $\mathcal{C}_{glob}$ is partial MDP.

Proof.

We start by proving Item 1. Let $\Delta_{i}\subseteq\Gamma_{i}$ be such that $|\Gamma_{i}\setminus\Delta_{i}|=\partial-1$ (i.e. $|\Delta_{i}|=r$ since $|\Gamma_{i}|=r+\partial-1$ in Construction 1), for $i=1,2,\ldots,g$. If $\Delta=\bigcup_{i=1}^{g}\Delta_{i}$ and $N=|\Delta|$, then the restricted code $(\mathcal{C}_{glob})_{\Delta}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$ is the $(N,k)$ convolutional code given by

[TABLE]

Since $\mathcal{C}_{loc}\subseteq\mathbb{F}_{q}^{r+\partial-1}$ is an $(r+\partial-1,r)$ MDS block code and $|\Delta_{i}|=r$, we deduce that $A|_{\Delta_{i}}\in\mathbb{F}_{q}^{r\times r}$ is invertible, for $i=1,2,\ldots,g$. Thus $(\mathcal{C}_{glob})_{\Delta}$ is non-catastrophic by Lemma 2, and moreover by (15) and Lemma 6, we have that

[TABLE]

Hence $(\mathcal{C}_{glob})_{\Delta}$ is $j$-MDS and Item 1 follows.

Now, Item 2 follows from the fact that $\mathcal{C}_{glob}=\mathcal{C}_{out}\operatorname{Diag}_{g}(A)$, and multiplying by the full-rank constant matrix $\operatorname{Diag}_{g}(A)\in\mathbb{F}_{q^{m}}^{N\times n}\subseteq\mathbb{F}_{q^{m}}[D]^{N\times n}$ on the right preserves degrees. Finally, Item 3 follows by combining Items 1 and 2. ∎

Finally, by plugging in the previous theorem the $L$-MSRD codes from [21] (see Appendix B) as outer codes in Construction 1, we show the existence of partial MDP convolutional codes.

Corollary 2**.**

If $N=gr$, $(N-k)|\delta$, $M=\max\{N-k,k\}$, $L=\lfloor\frac{\delta}{k}\rfloor+\delta/(N-k)$, $q\geq r+\partial-1$ and $m\geq q^{M(L+2)-1}$, then the convolutional code from Corollary 1 is an $(n,k,r,\partial)$ partial MDP convolutional code.

Observe that we could have given the previous corollary first, and then deduce Corollary 1 from Proposition 5. However, we have chosen to present our results in this order for simplicity.

6 Further Considerations

6.1 Unequal Localities and Local Distances

Locally repairable codes with unequal localities were introduced independently in [15, 35]. Adding also unequal local distances was first considered in [6]. Essentially, locally repairable codes with unequal localities are those such that the locality $r$ and local distance $\partial$ depend on the local group $\Gamma_{i}$ (see Definition 10). In other words, the $i$th local group has locality $r_{i}$ and local distance $\partial_{i}$, for $i=1,2,\ldots,g$. We may then modify Definition 10 to include unequal localities and local distances by adding indices to Items 1 and 2:

$|\Gamma_{i}|\leq r_{i}+\partial_{i}-1$, 2. 2.

$\operatorname{d}(\mathcal{C}_{\Gamma_{i}}^{0})\geq\partial_{i}$,

for $i=1,2,\ldots,g$. The main motivation for this type of locally repairable codes is that some nodes may require faster repair or access (hot data), while considering the different localities in general improves the global correction capability of the code.

Finding analogous upper bounds to (5) is a challenging task in general. Such bounds are known when $r_{1}\leq r_{2}\leq\ldots\leq r_{g}$ and $\partial_{1}\geq\partial_{2}\geq\ldots\geq\partial_{g}$ (see [6, Th. 2] and [17, Th. 2]).

On the other hand, adapting the notion of partial MDS codes to unequal localities is straightforward (see [24, Def. 5]). In addition, it was proven in [24, Th. 2] that MSRD block codes used as outer codes always give partial MDS codes, for any choice of unequal localities and local distances.

All the results in this work hold also for unequal localities and local distances. As in the block case, bounds on the column distances are not straightforward in general. However, Construction 1 with the MSRD codes from Appendix B as outer codes provide partial MDP codes for an arbitrary choice of unequal localities and local distances, just as in the block case. We leave the details to the reader.

6.2 Tail-Biting LRCCs

LRCCs may encode an unrestricted number of information symbols (i.e. files or file components), while locality and sliding-window erasure-correction capability and complexity remain constant. However, truncating an $(n,k)$ LRCC $\mathcal{C}$ at a given block $t$ implies that, for $h\in\mathbb{N}$, the final windows $(v_{t-h},v_{t-h+1},\ldots,v_{t})$ cannot be the initial part of a sliding window consisting of $j+1>h+1$ blocks, which could potentially correct $\operatorname{d}^{c}_{j}(\mathcal{C})-1>\operatorname{d}^{c}_{h}(\mathcal{C})-1$ erasures. Therefore, in such a truncated LRCC, certain blocks receive a weaker protection against erasures.

To provide equal protection to all blocks, one solution is to terminate the LRCC as a block code by converting it into a tail-biting convolutional code. This simply requires updating the first $\mu$ blocks using the last $\mu$, in the way they would be encoded if we had used the generator matrix

[TABLE]

where $G(D)=\sum_{j=0}^{\mu}G_{j}D^{j}\in\mathbb{F}[D]^{k\times n}$ is a reduced generator matrix of the LRCC. In this way, sliding-window repair behaves equally in any window of the same size. However, we always need to have at least $\mu$ consecutive blocks with no erasures in order to get the repair started, although this $\mu$ consecutive blocks may be arbitrary and not necessarily the first $\mu$. In other words, any $\mu$ consecutive blocks may be considered initial in a tail-biting convolutional code.

Acknowledgement

The first author is supported by The Independent Research Fund Denmark (Grant No. DFF-7027-00053B). The second author is partially supported by the Generalitat Valenciana (Grant No. AICO/2017/128) and the Universitat d’Alacant (Grant No. VIGROB-287).

Appendix A A Lemma on Information Sets of Optimal Block LRCs

In this appendix, we prove the following result on the information sets of optimal block LRCs. Essentially, we follow a simplified version of the proof of [29, Th. 21], using linear LRCs, thus dimensions instead of entropies, and for pair-wise disjoint local groups of size exactly $r+\partial-1$, for $(r,\partial)$-localities.

Lemma 7**.**

Let $\mathcal{C}_{0}\subseteq\mathbb{F}^{n}$ be a $k$-dimensional block linear LRC with $(r,\partial)$-localities, where we are considering pair-wise disjoint local groups of size exactly $r+\partial-1$: $[n]=\Gamma_{1}\cup\Gamma_{2}\cup\ldots\cup\Gamma_{g}$, where $\Gamma_{i}\cap\Gamma_{j}=\varnothing$ if $i\neq j$, and $|\Gamma_{i}|=r+\partial-1$, for $i=1,2,\ldots,g$. Define $\ell=\left\lceil k/r\right\rceil$, and assume that $\mathcal{C}_{0}$ has maximum possible minimum Hamming distance, i.e.,

[TABLE]

Then there are $\ell$ local groups, which we may assume without loss of generality that they are the first $\ell$ of them, $\Gamma_{1},\Gamma_{2},\ldots,\Gamma_{\ell}$, such that

[TABLE]

where $\mathcal{C}_{\Gamma}\subseteq\mathbb{F}^{|\Gamma|}$ denotes the restriction of a block code $\mathcal{C}\subseteq\mathbb{F}^{n}$ onto the coordinates in $\Gamma\subseteq[n]$.

Proof.

We proceed as in the proof of [29, Th. 21], and define the following algorithm, which finds a size-$\ell$ subset $\mathcal{I}\subseteq[g]$ of local groups satisfying the properties in the lemma. As explained above, this algorithm is the same as that in the proof of [29, Th. 21], but considering only linear LRCs, replacing entropies by dimensions, and considering pair-wise disjoint local groups of size exactly $r+\partial-1$, for $(r,\partial)$-localities.

1:  Set $\mathcal{I}=\varnothing$ and $\mathcal{A}=\varnothing$.

2:  while $\dim\left((\mathcal{C}_{0})_{\mathcal{A}}\right)<k$ do

3:     Pick an index $i\in[g]\setminus\mathcal{I}$.

4:     if  $\dim\left((\mathcal{C}_{0})_{\mathcal{A}\cup\Gamma_{i}}\right)<k$  then

5:         Set $\mathcal{I}:=\mathcal{I}\cup\{i\}$.

6:         Set $\mathcal{A}:=\mathcal{A}\cup\Gamma_{i}$.

7:     else if  $\dim\left((\mathcal{C}_{0})_{\mathcal{A}\cup\Gamma_{i}}\right)\geq k$ and $\exists\Delta\subseteq\Gamma_{i}$ s.t. $\dim\left((\mathcal{C}_{0})_{\mathcal{A}\cup\Delta}\right)<k$  then

8:         Set $\mathcal{I}:=\mathcal{I}\cup\{i\}$.

9:         Set $\mathcal{A}:=\mathcal{A}\cup\Delta$.

10:     else

11:         end while

12:     end if

13:  end while

14:  return  $\mathcal{I},\mathcal{A}$

Now we run the algorithm above. As in the proof of [29, Th. 21], there may be only the following two cases.

Case 1: Assume that the algorithm terminates with the final sets $\mathcal{I}$ and $\mathcal{A}$ assigned at lines 5 and 6, respectively. Since the algorithm has terminated at this point, if we consider any $i\in[g]\setminus\mathcal{I}$, then

[TABLE]

Hence we reassign $\mathcal{I}:=\mathcal{I}\cup\{i\}$, and then it must hold that

[TABLE]

since adding a local group may not increase the dimension of the restricted code by more than $r$, since $\partial-1$ out of $r+\partial-1$ coordinates in a local group are redundant.

Case 2: Assume that the algorithm terminates with the final sets $\mathcal{I}$ and $\mathcal{A}$ assigned at lines 8 and 9, respectively. In this case, we already have that

[TABLE]

thus, without reassigning $\mathcal{I}$, we also deduce that

[TABLE]

In any of the two cases, Case 1 or Case 2, assume that $|\mathcal{I}|>\ell$. Following the same steps as in the proof of [29, Th. 21], we have that ($\partial>1$)

[TABLE]

This contradicts the optimality of the LRC $\mathcal{C}_{0}$, hence the case $|\mathcal{I}|>\ell$ may not happen. Therefore, it must hold that $|\mathcal{I}|=\ell$, in both Case 1 and Case 2. Also in both cases, the local groups $\Gamma_{j}$, for $j\in\mathcal{I}$, satisfy the properties of the lemma, i.e.,

[TABLE]

and thus we are done. ∎

Appendix B Known Construction of MSRD Convolutional Codes

In this appendix, we revisit the construction of non-catastrophic MSRD convolutional codes from [21], which is based on the superregular matrices introduced in [1]. To the best of our knowledge, this is the only known construction of MSRD convolutional codes. In addition, they admit general parameters, except that they usually require impractically large field sizes. Acceptable field sizes can be achieved for certain parameters. See Table I in [21] for a few instances.

Fix $1\leq k\leq N$. As in [1], see also [2], we will restrict ourselves to $(N,k)$ convolutional codes whose degree $\delta$ satisfies that $(N-k)|\delta$, for general parameters see [27]. Define $M=\max\{N-k,k\}$ and $L=\lfloor\frac{\delta}{k}\rfloor+\delta/(N-k)$, as in (2). Let $q$ be any prime power and assume that

[TABLE]

The field will be then $\mathbb{F}=\mathbb{F}_{q^{m}}$. Let $\alpha\in\mathbb{F}_{q^{m}}$ be a primitive normal element over $\mathbb{F}_{q}$, that is, a primitive element of $\mathbb{F}_{q^{m}}$ such that $\alpha,\alpha^{q},\ldots,\alpha^{q^{m-1}}$ form a basis of $\mathbb{F}_{q^{m}}$ over $\mathbb{F}_{q}$. Such element exists for any finite field extension $\mathbb{F}_{q}\subseteq\mathbb{F}_{q^{m}}$ (see [18]). Define the matrix

[TABLE]

for $j=0,1,2,\ldots,L$, where $\alpha^{[i]}=\alpha^{q^{i}}$, for $i\in\mathbb{N}$. Finally, define the non-catastrophic $(N,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}_{q^{m}}[D]^{N}$ as that with polynomial parity-check matrix

[TABLE]

[TABLE]

where $\nu=\delta/(N-k)$, $A_{0}=I_{N-k}$, and $B$ can be given from $A$ by the rule

[TABLE]

The following theorem combines [9, Th. 3.1] with [21, Th. 5].

Theorem 5**.**

The $(N,k)$ convolutional code $\mathcal{C}\subseteq\mathbb{F}_{q^{m}}^{N}$ described above is non-catastrophic, has degree $\delta$ and is $L$-MSRD for any sum-rank length decomposition of $N$.