Codes for Graph Erasures

TL;DR

This paper introduces a new class of codes over graphs designed to efficiently recover from node failures in systems like neural networks and distributed systems, with constructions that reduce field size requirements.

Contribution

It presents novel constructions of codes over graphs that correct multiple node failures using smaller fields, including optimal codes over binary fields for prime node counts.

Findings

Optimal codes over graphs correcting two node failures over binary fields.

Construction of codes correcting multiple node failures with reduced field size.

Improved code constructions for specific failure scenarios.

Abstract

Motivated by systems where the information is represented by a graph, such as neural networks, associative memories, and distributed systems, we present in this work a new class of codes, called codes over graphs. Under this paradigm, the information is stored on the edges of an undirected graph, and a code over graphs is a set of graphs. A node failure is the event where all edges in the neighborhood of the failed node have been erased. We say that a code over graphs can tolerate $\rho$ node failures if it can correct the erased edges of any $\rho$ failed nodes in the graph. While the construction of such codes can be easily accomplished by MDS codes, their field size has to be at least $O(n^2)$, when $n$ is the number of nodes in the graph. In this work we present several constructions of codes over graphs with smaller field size. In particular, we present optimal codes over graphs correcting two node failures over the binary field, when the number of nodes in the graph is a prime number. We also present a construction of codes over graphs correcting $\rho$ node failures for all $\rho$ over a field of size at least $(n+1)/2-1$, and show how to improve this construction for optimal codes when $\rho=2,3$.

Equations

$$\left(\genfrac{}{}{0ex}{}{n+1}{2}\right)-\left(\genfrac{}{}{0ex}{}{n-\rho +1}{2}\right)=\rho n-\left(\genfrac{}{}{0ex}{}{\rho }{2}\right).$$

$$r_{\mathcal{G}}⩾\left(\genfrac{}{}{0ex}{}{n+1}{2}\right)-\left(\genfrac{}{}{0ex}{}{n-\rho +1}{2}\right)=\rho n-\left(\genfrac{}{}{0ex}{}{\rho }{2}\right).$$

$$S_{m}=\begin{cases}\big{\{}(v_{m},v_{\ell})~{}|~{}\ell\in[n-1]\big{\}}&,m\in[n-2],\\ \big{\{}(v_{\ell},v_{\ell})~{}\hskip 2.58334pt|~{}\ell\in[n-1]\big{\}}&,m=n-2.\\ \end{cases}$$

$$D_m=$$

$$\mathcal{C}_{{\cal G}_{1}}=\left\{G=(V_{n},L)\middle|\begin{array}[]{cc}(a)\sum_{(v_{i},v_{j})\in S_{m}}L(v_{i},v_{j})=0,m\in[n-1]\\ (b)\sum_{(v_{i},v_{j})\in D_{m}}L(v_{i},v_{j})=0,m\in[n]\end{array}\right\}.\vspace{-0.5ex}$$

$${\hat{S}}_m=\sum _{\begin{array}{c}(v_k,v_{\ell })\in S_m\setminus (F_i\cup F_j)\end{array}}L(v_k,v_{\ell }),\text{vspace}-1ex$$

$${\hat{D}}_m=\sum _{\begin{array}{c}(v_k,v_{\ell })\in D_m\setminus (F_i\cup F_j)\end{array}}L(v_k,v_{\ell }).\text{vspace}-1ex$$

$$s_1^{(t)}=⟨-d(t+1)-2{⟩}_n,s_2^{(t)}=⟨s_1^{(t)}+j{⟩}_n=⟨-dt+i-2{⟩}_n.\text{vspace}-1ex$$

$$A=\{s_1^{(t_1)}|0⩽t_1⩽x\},B=\{{\tilde{s}}_1^{(t_2)}|0⩽t_2⩽y\}.\text{vspace}-1ex$$

$$D_{⟨i-2{⟩}_n}\cap (F_i\cup F_j)=\{(v_{⟨i-j-2{⟩}_n},v_j)\}=\{(v_{⟨-d-2{⟩}_n},v_j)\}\text{vspace}-1ex$$

$$S_{⟨-d-2{⟩}_n}\cap (F_i\cup F_j)=\{(v_{⟨-d-2{⟩}_n},v_i),(v_{⟨-d-2{⟩}_n},v_j)\},\text{vspace}-1ex$$

$$L(v_{⟨-d-2{⟩}_n},v_i)={\hat{S}}_{⟨-d-2{⟩}_n}+L(v_{⟨-d-2{⟩}_n},v_j).$$

$$D_{s_2^{(t)}}\cap (F_i\cup F_j)$$

$$=\{(v_{s_1^{(t-1)}},v_i),(v_{s_1^{(t)}},v_j)\}.$$

$$D_{s_2^{(t)}}\cap (F_i^{(t)}\cup F_j^{(t)})=\{(v_{s_1^{(t)}},v_j)\},\text{vspace}-1ex$$

$$S_{s_1^{(t)}}\cap (F_i\cup F_j)=\{(v_{s_1^{(t)}},v_i),(v_{s_1^{(t)}},v_j)\},\text{vspace}-1.5ex$$

$${\tilde{F}}^{(y)}=\{(v_i,v_j),(v_{n-2},v_i),(v_{n-2},v_j)\},\text{vspace}-1ex$$

$$k=\{\begin{array}{ll}n(n-d+2)/2& ,n-d\text{is even},\\ (n+1)(n-d+1)/2& ,n-d\text{is odd},\end{array}\text{vspace}-1ex$$

$$k=\{\begin{array}{ll}n(n-2\rho +1)/2& ,n\text{is odd},\\ (n+1)(n-2\rho )/2& ,n\text{is even},\end{array}\text{vspace}-1ex$$

$${\mathcal{C}}_{{\mathcal{G}}_2}=\left\{G=(V_n,L)|A_G\in \mathcal{C}\right\}.$$

$$k_{\mathcal{G}}=\{\begin{array}{ll}n(n-2\rho +1)/2& ,n\text{is odd},\\ (n+1)(n-2\rho )/2& ,n\text{is even},\end{array}\text{vspace}-1ex$$

$$r_{\mathcal{G}}=\{\begin{array}{ll}n\rho & ,n\text{is odd},\\ (n+1)\rho & ,n\text{is even},\end{array}\text{vspace}-1ex$$

$$P_{\rho }=\{(v_k,v_{\ell })|k,\ell \in [n-\rho ],k>\ell \}\text{vspace}-0.5ex,$$

$$\{(i,j)\in [n-3{]}^2|i>j\}\cup \{(n-2,n-2),(n-1,n-2),(n-1,n-1)\},$$

$${\cal H}_{\widetilde{P}_{3}}=\footnotesize\blockarray{*{7}{c}l}\block{*{7}{>{\tiny}c<{}}l}(1,0)&(2,0)\small\ldots(n-3,n-4)(n-2,n-2)(n-1,n-2)(n-1,n-1)\\ \block{[*{7}{c}]>{\footnotesize}l<{}}\alpha^{0}_{\langle 1+0\rangle_{n}}&\alpha^{0}_{\langle 2+0\rangle_{n}}\ldots\alpha^{0}_{\langle n-3+n-4\rangle_{n}}100\\ \alpha^{1}_{\langle 1+0\rangle_{n}}\alpha^{1}_{\langle 2+0\rangle_{n}}\ldots\alpha^{1}_{\langle n-3+n-4\rangle_{n}}010\\ \alpha^{2}_{\langle 1+0\rangle_{n}}\alpha^{2}_{\langle 2+0\rangle_{n}}\ldots\alpha^{2}_{\langle n-3+n-4\rangle_{n}}001\\ .$$

$$|N_m\cap (F_i\cup F_j\cup F_k)|=3.\text{vspace}-3ex$$

$${\mathcal{C}}_{{\mathcal{G}}_3}=\left\{G=(V_n,L)|\forall m\in [n-2],{\mathbf{c}}_{N_m}\in {\mathcal{C}}_N,{\mathbf{c}}_{{\tilde{P}}_3}\in {\mathcal{C}}_{{\tilde{P}}_3}\right\}.$$

$$[u_0,u_1,u_2]\cdot [{\mathbf{g}}_{i,i},{\mathbf{g}}_{i,j},{\mathbf{g}}_{j,j}]=[c_{i,i},c_{i,j},c_{j,j}],\text{vspace}-0.5ex$$

$$q^{2\left(\genfrac{}{}{0ex}{}{n}{2}\right)}(q-1{)}^{\left(\genfrac{}{}{0ex}{}{n+1}{2}\right)}\frac{(q^2+q+1)!}{(q^2+q+1-n)!}.$$

Full text

I Introduction

The traditional setup to represent information is by a vector over some fixed alphabet. Although this commonly used model is the most practical one, especially for storage and communication applications, it does not necessarily fit all information systems. In this work we study a different approach where the information is represented by a graph. This model is motivated by several information systems. For example, in neural networks, the neural units are connected via links which store and transmit information between the neural units [5]. Similarly, in associative memories, the information is stored by associations between different data items [11]. These two examples mimic the brain functionality which stores and processes information by associations between the information units. Furthermore, representing information in a graph can model a distributed storage systems [3] while every two nodes can share a link with the information that is stored between the nodes.

In this paper we present a new class of codes which we call codes over graphs. Under this setup we assume that there is an undirected complete graph with $n$ nodes (vertices) such that the information is stored on the edges connecting between every two nodes in the graph, including self loops. The information on each edge is a symbol over some fixed alphabet so every graph can be represented by the symbols stored in each of the $\binom{n+1}{2}$ edges, and a code over graphs is simply a set of graphs. A node failure is the event where all edges in the node’s neighborhood have been erased, and the goal of this work is to construct codes over graphs that can efficiently correct node failures. Namely, we say that a code over graphs can correct $\rho$ node failures if it is possible to correct the erased edges in the neighborhoods of any failed $\rho$ nodes. We study node failures since they correspond to the events of failing neural units in a neural network, data loss in an associative memory, and unavailable and failed nodes in distributed storage systems.

Since every graph can be represented by its adjacency matrix, a natural approach to construct codes over graphs is by their adjacency matrices. Thus, this class of codes is quite similar to the class of array codes, such as maximum-rank array codes [7], B codes [10], EVENODD codes [1], RDP code [2], X-codes [10], and regenerating codes [4, 6, 9]. However, there are two main differences between classical array codes and codes over graphs. First, since the graphs are undirected, the matrices are symmetric and square. Second, a failure of the $i$th node in the graph corresponds to the failure of the $i$th row and $i$th column in the adjacency matrix. Most existing constructions of array codes are not designed for symmetric or even square matrices. Furthermore, these constructions do not support the row-column failure model. The closest model to this setup is the one studied by Roth for crisscross errors [7], in which a fixed number of rows and columns have failed. While it is possible to use some of the results from [7], we will show in the paper that they do not provide codes over graphs with good parameters.

Assume a code over graphs with $n$ nodes such that every edge stores a symbol. If $\rho$ nodes have failed then the number of edges that were erased is

[TABLE]

Therefore, the number of redundancy edges for every code which tolerates $\rho$ node failures is at least $\rho n-\binom{\rho}{2}$. A code over graphs which meets this lower bound on the number of redundancy edges will be called an optimal code over graphs. Note that it is possible to construct optimal codes over graphs by using an $[\binom{n+1}{2},\binom{n-\rho+1}{2},\rho n-\binom{\rho}{2}+1]$ MDS code. However, this will impose using a field of size at least $\binom{n+1}{2}-1=\Theta(n^{2})$. Thus, the problem under this setup is the construction of such codes over smaller fields with optimal or close to optimal redundancy.

The rest of this paper is organized as follows. In Section II, we formally define the graph model studied in this paper and some preliminary results. In Section III, we present our main result in the paper of optimal binary codes over graphs correcting two node failures, when the number of nodes is prime. In Section IV, we extend our results for codes over graphs correcting arbitrary number of node failures over a field of size at least $(n+1)/2-1$. While this construction is almost optimal with respect to the bound in (1), we show how to improve it for optimal codes correcting two and three node failures. Lastly, in Section V, we study the existence of codes over graphs correcting $n-2$ node failures. Due to the lack of space some proofs of the results in the paper are omitted.

II Definitions and Preliminaries

For a positive integer $n$, the set $\{0,1,\ldots,n-1\}$ will be denoted by $[n]$. For a prime power $q$, ${\smash{\mathbb{F}_{\!q}}}$ is the finite field of size $q$. A linear code of length $n$, dimension $k$, and minimum distance $d$ over $\smash{\mathbb{F}_{\!q}}$ will be denoted by $[n,k,d]_{q}$.

We will denote an undirected graph by $G=(V,E)$, where $V=\{v_{0},v_{1},\ldots,v_{n-1}\}$ is a set of $n$ nodes (vertices) and $E\subseteq V\times V$ is its edge set. By a slight abuse of notation, every (undirected) edge in the graph will be denoted by $(v_{i},v_{j})$ where the order in this pair does not matter, that is, the pair $(v_{i},v_{j})$ is identical to the pair $(v_{j},v_{i})$. When possible we will denote the edges by $(v_{i},v_{j})$, where $i\geqslant j$. We assume that the graph is simple in the sense that there are no parallel edges, however every node can have a self loop.

A graph $G$ over an alphabet $\Sigma$ is defined by a labeling function $L:E\rightarrow\Sigma$ and will be denoted by $G=(V,E,L)$. In this work we will extend the definition of the labeling function over $V\times V$, i.e. $L:V\times V\rightarrow\Sigma$, and have $0\in\Sigma$ denote the case in which an edge does not exist. Hence, we can fully characterize the graph $G$ by its vertex set $V$ and labeling function $L$, and will denote it by $G(V,L)$, where we simply consider it as a complete graph with self loops. Under this setup, the adjacency matrix of the graph $G$ is an $n\times n$ matrix $A_{G}=[a_{i,j}]^{n-1,n-1}_{i=0,j=0}$, where $a_{i,j}=L(v_{i},v_{j})$ for all $i,j\in[n]$. We will also use the lower-triangle-adjacency matrix of $G$ to be the $n\times n$ matrix $A_{G}^{\prime}=[a^{\prime}_{i,j}]^{n-1,n-1}_{i=0,j=0}$ such that $a^{\prime}_{i,j}=a_{i,j}$ if $i\geqslant j$ and otherwise $a^{\prime}_{i,j}=0$. For $i\in[n]$, the neighborhood of the $i$th node, denoted by $N_{i}$, is the set of edges connected to this node. Since we assumed the graph is complete, the neighborhood is simply the set $N_{i}=\{(v_{i},v_{j})|j\in[n]\}$.

Let $\Sigma$ be a ring and $G_{1}$ and $G_{2}$ be two graphs over $\Sigma$ with the same nodes set $V$. The operator $"+"$ between $G_{1}$ and $G_{2}$ over $\Sigma$, is defined by $G_{1}+G_{2}=G_{3}$, where $G_{3}$ is the unique graph satisfying $A_{G_{1}}+A_{G_{2}}=A_{G_{3}}$. Similarly, the operator $"\cdot"$ between $G_{1}$ and an element $\alpha\in\Sigma$, is denoted by $\alpha\cdot G_{1}=G_{3}$, where $G_{3}$ is the unique graph satisfying $\alpha\cdot A_{G_{1}}=A_{G_{3}}$.

Definition** 1**

. A code over graphs of size $M$, length $n$ over $\Sigma$ is a set of undirected graphs $\mathcal{C}_{{\cal G}}=\{G_{i}=(V_{n},L_{i})|i\in[M]\}$ over $\Sigma$ where $V_{n}=\{v_{0},\ldots,v_{n-1}\}$. We denote such a code by ${\cal G}\textmd{-}(n,M)_{\Sigma}$ and in case $\Sigma=\{0,1\}$, it will simply be denoted by ${\cal G}\textmd{-}(n,M)$. The dimension of a code over graphs $\mathcal{C}_{{\cal G}}$ is $k_{\cal G}=\log_{|\Sigma|}M$, the rate is $R_{\cal G}=k_{\cal G}/{{n+1\choose 2}}$, and the redundancy is defined to be $r_{\cal G}={n+1\choose 2}-k_{\cal G}$.

A code over graphs $\mathcal{C}_{{\cal G}}$ over a ring $\Sigma$ will be called linear if for every $G_{1},G_{2}\in\mathcal{C}_{{\cal G}}$ and $\alpha,\beta\in\Sigma$ it holds that $\alpha G_{1}+\beta G_{2}\in\mathcal{C}_{{\cal G}}$. We denote this family of codes over graphs by ${\cal G}\textmd{-}[n,k_{\cal G}]_{\Sigma}$.

A linear code over graphs whose first $k$ nodes contain the $\binom{k+1}{2}$ unmodified information symbols on their edges, is called a systematic code over graphs. All other $\binom{n+1}{2}-\binom{k+1}{2}$ edges in the graph are called redundancy edges. In this case we say that there are $k$ information nodes and $r=n-k$ redundancy nodes. The number of information edges is $k_{\cal G}={k+1\choose 2}$, the redundancy is $r_{\cal G}={n+1\choose 2}-{k+1\choose 2}$, and the rate is $R_{\cal G}={{k+1\choose 2}}/{{n+1\choose 2}}$. We denote such a code by ${\cal S}{\cal G}\textmd{-}[n,k]_{\Sigma}$.

A node failure is the event, where all the edges incident to the failed node are erased in the graph, that is, its neighborhood set. In this case the failed node is known and it is required to complete the values of the edges in the node’s neighborhood, which leads us to the following definition.

Definition** 2**

. A code over graphs is called a $\rho$-node-erasure-correcting code if it can correct the failure of any $\rho$ nodes in each graph in the code.

The minimum redundancy $r_{\cal G}$ of any $\rho$-node-erasure-correcting code of length $n$, satisfies

[TABLE]

A code over graphs satisfying this inequality with equality will be called optimal. Hence for systematic codes over graphs the number of redundancy nodes is at least $\rho$. Note that for all $n$ and $\rho$, one can always construct an optimal $\rho$-node-erasure-correcting code from an $[\binom{n+1}{2},\binom{n-\rho+1}{2},\rho n-\binom{\rho}{2}+1]$ MDS code. However, then the field size of the code will be at least $\binom{n+1}{2}-1=\Theta(n^{2})$. Our goal in this work is to construct $\rho$-node-erasure-correcting codes over small fields. When possible, we seek the field size to be binary and in any event at most ${\cal O}(n)$.

A closely related construction to our problem was given by Roth in [7]. In this work he presented a construction of maximum-rank array codes that can correct the failure of any combination of some $\mu$ rows and columns. Even though his construction results with square matrices, they are not necessarily symmetric. Yet, it is possible to slightly modify his construction in order to achieve ${\cal S}{\cal G}\textmd{-}[n,n-2\rho]_{q}$ $\rho$-node-erasure-correcting codes over $\mathbb{F}_{q}$ for $q\geqslant n-1$, and hence the number of redundancy edges is $2\rho n-\binom{2\rho}{2}$. We will show that our construction in Section IV can improve these codes such that the number of redundancy edges to construct $\rho$-node-erasure-correcting codes will be only $\rho n$. The next example exemplifies the definitions of codes over graphs.

Example** 1**

. The following codes over graphs, given in Fig. 1, is a binary systematic single-node-erasure-correcting code of length 3. The information bits are stored in the edges of the subgraph containing nodes $v_{0}$ and $v_{1}$. The remaining three redundancy edges are completed in a way that the edges in the neighborhood of each node belong to a simple parity code of length three.

The code construction from Example 1 is easily extended for arbitrary number of nodes by simple parity constraints for the neighborhoods of each node. Next we study the more interesting case of double-node-erasure-correcting codes.

III Double-Node-Erasure-Correcting Codes

In this section we present a construction of binary double-node-erasure-correcting codes. We use the notation $\langle a\rangle_{n}$ to denote the value of $(a\bmod n)$.

Throughout this section we assume that $n\geqslant 5$ is a prime number. Let $G=(V_{n},L)$ be a code over graphs with $n$ vertices. Let us define for $m\in[n-1]$

[TABLE]

and for $m\in[n]$

[TABLE]

The sets $S_{m}$ where $m\in[n-2]$, will be used to represent parity constraints on the neighborhood of each node, which correspond to rows in the adjacency matrix. Similarly, the sets $D_{m}$ will represent parity constraints on the diagonals of the adjacency matrix. Note that for all $m\in[n-1]$, $|S_{m}|~{}=~{}n~{}-~{}1$ and for all $m\in[n]$, $|D_{m}|=\frac{n+1}{2}$.

Example** 2**

. The sets $S_{m},D_{m}$ for $n=7$ are marked in Fig. 2(a). Note that entries on lines with the same color belong to the same parity constraints.

Recall that for $m\in[n]$ the failure set $F_{m}$ of the $m$th node is its neighborhood set which we denote by $F_{m}=\{(v_{m},v_{\ell})~{}|~{}\ell\in[n]\}$.

Claim 1

The sets $S_{m},D_{m},F_{m}$ satisfy the following properties.

1. (a)

For all pairwise distinct $i,j,h\in[n-2]$, $S_{h}\cap(F_{i}\cup F_{j})=\{(v_{h},v_{i}),(v_{h},v_{j})\}$. 2. (b)

For all distinct $i,j\in[n-2]$, $S_{n-2}\cap(F_{i}\cup F_{j})=\{(v_{i},v_{i}),(v_{j},v_{j})\}$. 3. (c)

For all $i\in[n-2]$, $s\in[n]\setminus\{{\langle i-2\rangle_{n}}\}$, $D_{s}\cap F_{i}=\{(v_{\langle s-i\rangle_{n}},v_{i})\}$. 4. (d)

For all distinct $i,j\in[n-2]$, $D_{\langle j-2\rangle_{n}}\cap(F_{i}\cup F_{j})=\{(v_{\langle j-i-2\rangle_{n}},v_{i})\}$. 5. (e)

For all distinct $i,j\in[n-2]$, $D_{\langle i+j\rangle_{n}}\cap(F_{i}\cup F_{j})=\{(v_{i},v_{j})\}$.

We are now ready to present the construction of binary ${\cal S}{\cal G}\textmd{-}[n,n-2]$ double-node-erasure-correcting codes.

Construction 1

For all $n\geqslant 5$ prime number let ${\cal C}_{{\cal G}_{1}}$ be the following code:

[TABLE]

Note that in this construction we had two sets of constraints. In the first set we had $n-1$ constraints and we call them constraint $S_{m}$ for $m\in[n-1]$. Similarly, we call constraint $D_{m}$ for $m\in[n]$. Furthermore, the edge $(v_{n-1},v_{n-2})$ appears in each of the diagonal sets in order to have successul decoding when the failed nodes are $i\in[n-2]$ and $j=n-2$ (due to the lack of space we do not consider this case in the proof). Lastly, the correctness of this construction could be proved by defining a minimum distance for codes over graphs and showing that the minimum distance of this code is 3. However, this will not provide a decoding algorithm as we present in the following proof.

Theorem** 3**

. The code $\mathcal{C}_{{\cal G}_{1}}$ is an optimal binary double-node-erasure-correcting code.

Proof:

Assume that nodes $i,j\in[n]$, where $i<j$ are the failed nodes. We will show the correctness of this construction by explicitly showing its decoding algorithm. We will only consider the more difficult case of $i,j\in[n-2]$.

In this case we show an explicit algorithm which decodes all the erased edges. First, we denote the single parity syndromes for $m\in[n-1]\setminus\{i,j\}$ by

[TABLE]

and the diagonal parity syndromes for $m\in[n]$ by

[TABLE]

Let $d=\langle j-i\rangle_{n}$, $x=\langle-1-d^{-1}\rangle_{n}$ and $y=\langle-1+d^{-1}\rangle_{n}$. The decoding procedure is described in Algorithm 1.

Denote $F^{(t)}$ as the set of uncorrected edges in the first loop and $\widetilde{F}^{(t)}$ in the second loop, so $F^{(0)}=F_{i}\cup F_{j}$ and $\widetilde{F}^{(0)}=F^{(x)}$. Denote $s_{1}^{(t)}$ and $s_{2}^{(t)}$ the values of $s_{1}$ and $s_{2}$ respectively on iteration $t$ in the first loop. The values of $\widetilde{s}_{1}^{(t)}$ and $\widetilde{s}_{2}^{(t)}$ will be defined similarly for the second loop. The values of $s_{1}^{(t)}$ and $s_{2}^{(t)}$ are given by:

[TABLE]

Similar expressions can be derived for $\widetilde{s}_{1}^{(t)}$ and $\widetilde{s}_{2}^{(t)}$. Next, we denote the following sets.

[TABLE]

Claim 2

The following properties holds:

1. (a)

$x\neq y$ and $x+y=n-2$. 2. (b)

$s^{(x)}_{1}=\widetilde{s}^{(y)}_{1}=n-1$. 3. (c)

$i,j\in A$ or $i,j\in B$ but not in both. 4. (d)

$n-2\notin A\cup B$. 5. (e)

$|A|=x+1$, $|B|=y+1$ and $A\cap B=\{n-1\}$

According to Claim 2(c), the variable $s_{1}$ in Algorithm 1 gets the values of $i$ and $j$ either in the first or the second loop. Let us assume for the rest of the proof that this happens in the first loop, i.e. $i,j\in A$, while the second case is proved similarly. We are now ready to show the correctness of the first loop by induction while the proof for the second loop is very similar.

Lemma** 4**

. For all $0\leqslant t\leqslant x$, the following properties hold:

If $s_{1}^{(t)}\notin\{i,j,n-1\}$ then $D_{s_{2}^{(t)}}\cap F^{(t)}=\{(v_{s_{1}^{(t)}},v_{j})\}$, $S_{s_{1}^{(t)}}\cap F^{(t)}=\{(v_{s_{1}^{(t)}},v_{i}),(v_{s_{1}^{(t)}},v_{j})\}$, and the edges $(v_{s_{1}^{(t)}},v_{j}),(v_{s_{1}^{(t)}},v_{i})$ are corrected on the $t$th iteration. 2. 2.

If $s_{1}^{(t)}=j$ then $D_{s_{2}^{(t)}}\cap F^{(t)}=\{(v_{j},v_{j})\}$, $S_{n-2}\cap F^{(t)}=\{(v_{i},v_{i}),(v_{j},v_{j})\}$ and the edges $(v_{i},v_{i}),(v_{j},v_{j})$ is corrected on the $t$th iteration. 3. 3.

If $s_{1}^{(t)}=n-1$ then $D_{s_{2}^{(t)}}\cap F^{(t)}=\{(v_{n-1},v_{j})\}$ and the edge $(v_{n-1},v_{j})$ is corrected on the $t$th iteration.

Proof:

We prove this claim by induction on $t$.

Base: For $t=0$ we have $s_{1}^{(0)}=\langle-d-2\rangle_{n}$, $s_{2}^{(0)}=\langle i-2\rangle_{n}$, and $F^{(0)}=F_{i}\cup F_{j}$. Note that in this case, $s_{1}^{(0)}\neq i$, we will also assume that $s_{1}^{(0)}\notin\{j,n-1\}$ since these cases are proved similarly. Hence, we need to show that,

$D_{\langle i-2\rangle_{n}}\cap(F_{i}\cup F_{j})=\{(v_{\langle-d-2\rangle_{n}},v_{j})\}$, 2. 2.

$S_{\langle-d-2\rangle_{n}}\cap(F_{i}\cup F_{j})=\{(v_{\langle-d-2\rangle_{n}},v_{i}),(v_{\langle-d-2\rangle_{n}},v_{j})\}$. 3. 3.

The edges $(v_{\langle-d-2\rangle_{n}},v_{j})$ and $(v_{\langle-d-2\rangle_{n}},v_{i})$ are corrected on this iteration.

The proof consists of the following observations:

• •

According to Claim 1(d) we deduce that

[TABLE]

and therefore the edge $(v_{\langle-d-2\rangle_{n}},v_{j})$ is corrected in Step 6 according to the constraint $D_{\langle i-2\rangle_{n}}$, therefore, $L(v_{\langle-d-2\rangle_{n}},v_{j})=\widehat{D}_{\langle i-2\rangle_{n}}$.

• •

According to Claim 1(a) we get

[TABLE]

and therefore the edge $(v_{\langle-d-2\rangle_{n}},v_{i})$ is corrected in Step 7 according to the constraint $S_{\langle-d-2\rangle_{n}}$, by

[TABLE]

Step: Assume that the property holds for $t-1$, where $t\leqslant x$ and we prove its correctness for $t$. In this case, by Claim 2(b) and Claim 2(e) we have that $s_{1}^{(t-1)}\neq n-1$, so we will need to distinguish between the following cases: 1. $s_{1}^{(t-1)}=j$, 2. $s_{1}^{(t-1)}=i$, and 3. $s_{1}^{(t-1)}\neq i,j$. We will prove the claim for the third case while the first two cases are handled similarly. Hence, we assume that the edges $(v_{s_{1}^{(t-1)}},v_{j})$ and $(v_{s_{1}^{(t-1)}},v_{i})$, were corrected on iteration $t-1$. Since we assumed that $s_{1}^{(t-1)}\neq j$, we can deduce that $s_{1}^{(t)}\neq i$, and we consider three cases:

$s_{1}^{(t)}\neq j,n-1$: It is possible to show that $s^{(t)}_{2}\notin\{\langle i-2\rangle_{n},\langle j-2\rangle_{n}\}$ and by Claim 1(c), we deduce that

[TABLE]

By the induction assumption $(v_{s^{(t-1)}_{1}},v_{i})$ was corrected, so,

[TABLE]

and the edge $(v_{s_{1}^{(t)}},v_{j})$ is successfully corrected in Step 6 by constraint $D_{s^{(t)}_{2}}$. Furthermore, by Claim 2(d) $s^{(t)}_{1}\neq n-2$ and since $s^{(t)}_{1}\neq n-1$, by Claim 1(a),

[TABLE]

so it holds that $S_{s^{(t)}_{1}}\cap(F^{(t)}_{i}\cup F^{(t)}_{j})=\{(v_{s^{(t)}_{1}},v_{i}),(v_{s^{(t)}_{1}},v_{j})\}$ and therefore the edge $(v_{s^{(t)}_{1}},v_{i})$ can be successfully corrected in Step 7 by constraint $S_{s^{(t)}_{1}}$ and the value of $L(v_{s^{(t)}_{1}},v_{j}).$ 2. 2.

$s_{1}^{(t)}=j$: As in the previous case, we first correct the edge $(v_{s_{1}^{(t)}},v_{j})=(v_{j},v_{j})$ by constraint $D_{s^{(t)}_{2}}$. Then, by Claim 1(b), $S_{n-2}\cap(F_{i}\cup F_{j})=\{(v_{i},v_{i}),(v_{j},v_{j})\}$ so it holds that $S_{n-2}\cap(F^{(t)}_{i}\cup F^{(t)}_{j})=\{(v_{i},v_{i}),(v_{j},v_{j})\}$ and therefore the edge $(v_{i},v_{i})$ is corrected in Step 11 by constraint $S_{n-2}$ and the value of $L(v_{j},v_{j}).$ 3. 3.

$s_{1}^{(t)}=n-1$: This case is proved similarly as in the previous case.

∎

The correctness of the second loop is proved similarly. Finally, it is possible to show that at the end of the algorithm the set of uncorrected edges is

[TABLE]

which can be corrected by the same arguments we used before. This completes the theorem’s proof. ∎

The decoding algorithm presented in the proof of Theorem 3 is demonstrated in the next example.

Example** 3**

. We consider the case where $n=11$ and the failed nodes are $v_{3}$ and $v_{5}$, that is, $i=3,j=5$. Therefore $d=2$ and $x=4,y=5$. We use here the lower-triangle-adjacency matrix. The first loop starts with the edge $(v_{7},v_{5})$, and ends with the edge $(v_{10},v_{5})$. Similarly, the second loop starts with the edge $(v_{3},v_{0})$ and ends with the edges $(v_{10},v_{3})$. At the end of this algorithm, $(v_{5},v_{3}),(v_{9},v_{3}),(v_{9},v_{5})$ are the uncorrected edges and are marked in blue.

IV Multiple-Node-Erasure-Correcting Codes

In this section we present constructions of $\rho$-node-erasure-correcting codes for arbitrary $\rho$. An $[n\times n,k,d]$ symmetric linear array code ${\cal C}$ over a field $\mathbb{F}$ is a $k$-dimensional linear space of $n\times n$ symmetric matrices over $\mathbb{F}$, where the minimum rank of all nonzero matrices in ${\cal C}$ is $d$. According to [7], these codes can correct the erasure of any $d-1$ rows or columns in the array. A construction of binary $[n\times n,k,d]$ symmetric linear array codes where

[TABLE]

was shown in [8]. Based on these codes, we present the following construction of binary $\rho$-node-erasure-correcting codes.

Construction 2

Let ${\cal C}$ be an $[n\times n,k,d=2\rho+1]$ symmetric binary array code from [8], where

[TABLE]

and $\rho<n/2$. The code over graphs ${\cal C}_{{\cal G}_{2}}$ is defined as follows,

[TABLE]

Theorem** 5**

. For all $\rho<n/2$ and

[TABLE]

the code $\mathcal{C}_{{\cal G}_{2}}$ is a ${\cal G}\textmd{-}[n,k_{\cal G}]$ $\rho$-node-erasure-correcting code.

Note that this construction does not provide optimal $\rho$-node-erasure-correcting codes since

[TABLE]

which does not meet the bound in (2). For example, for $\rho=2$ the difference between the code redundancy and the bound is one redundancy bit for $n$ odd and three bits for $n$ even. We note that for $n$ even we have another construction with redundancy $r_{\cal G}=n\rho$, however it requires a field of size $q\geqslant n/2$. Lastly, we prove that it is possible to construct optimal systematic codes for $\rho=2,3$ for $q\geqslant n+1$; due to the lack of space we only present the construction for $\rho=3$.

Let $G=(V_{n},L)$ be a graph over a field $\mathbb{F}_{q}$. For a set of edges $U\subseteq V_{n}\times V_{n}$, we define ${\boldsymbol{c}}_{U}\in\mathbb{F}_{q}^{|U|}$ to be a vector over $\mathbb{F}_{q}$ of length $|U|$, where its entries are the labels of the edges in the set $U$, in their lexicographic order, while we treat every edge as $(v_{i},v_{j})$, with $i\geqslant j$. For example, if $U=\{(v_{1},v_{0}),(v_{6},v_{3}),(v_{6},v_{2}),(v_{5},v_{3})\}$, then {\boldsymbol{c}}_{U}=\big{(}L(v_{1},v_{0}),L(v_{5},v_{3}),L(v_{6},v_{2}),L(v_{6},v_{3})\big{)}.

For $\rho\geqslant 2$, let $P_{\rho}$ be the set of all edges connecting between the first $n-\rho$ nodes but without the self loops, i.e.,

[TABLE]

and let $\widetilde{P}_{3}=P_{3}\cup\{(v_{n-2},v_{n-2}),(v_{n-1},v_{n-2}),(v_{n-1},v_{n-1})\}$. Next we define a new family of codes. Let $\mathbb{F}_{q}$ be a field of size at least $n+1$ and let $\alpha_{0},\alpha_{1},\ldots,\alpha_{n-1}\in\mathbb{F}_{q}$ be $n$ nonzero different elements in the field. Let ${\cal H}_{\widetilde{P}_{3}}$ be the following $3\times(\binom{n-3}{2}+3)$ matrix. The columns of the matrix are indexed by the entries corresponding to the edge set $\widetilde{P}_{3}$, that is, the set

[TABLE]

in their lexicographic order,

[TABLE]

Hence, each column in the matrix with index $(i,j)$ represents the edge $(v_{i},v_{j})$ in the graph. The $[{n-3\choose 2}+3,{n-3\choose 2}]_{q}$ code over a field of size $q\geqslant n+1$, whose parity check matrix is ${\cal H}_{\widetilde{P}_{3}}$ will be denoted by ${\cal C}_{\widetilde{P}_{3}}$.

Claim 3

For all $i,j,k\in[n-3]$, where $i<j<k$ the columns in the matrix ${\cal H}_{\widetilde{P}_{3}}$ with indices $(i,j),(i,k),(j,k)$ are linearly independent.

Proof:

For all $i,j,k\in[n-3]$, where $i<j<k$ we have that the elements $\alpha_{\langle i+j\rangle_{n}},\alpha_{\langle i+k\rangle_{n}},\alpha_{\langle j+k\rangle_{n}}$ are all different from each other. Therefore, the columns in the matrix ${\cal H}_{\widetilde{P}_{3}}$ with indices $(i,j),(i,k),(j,k)$ form a $3\times 3$ Vandermonde matrix and in particular are linearly independent. ∎

Claim 4

For all pairwise distinct $i,j,k,m\in[n]$,

[TABLE]

We are now ready to present the construction of triple-node-erasure-correcting codes.

Construction 3

Let $n\geqslant 3$ be a positive integer and $q\geqslant n+1$ be a prime power. Let ${\cal C}_{N}$ be an $[n,n-3,4]_{q}$ MDS code. Let ${\cal C}_{\widetilde{P}_{3}}$ be an $[{n-3\choose 2}+3,{n-3\choose 2}]_{q}$ code. The code ${\cal C}_{{\cal G}_{3}}$ is defined as follows,

[TABLE]

Theorem** 6**

. The code $\mathcal{C}_{{\cal G}_{3}}$ is a ${\cal G}\textmd{-}[n,k_{\cal G}=\binom{n-2}{2}]_{q}$ triple-node-rasure-correcting code, for $q\geqslant n+1$.

Proof:

Let $v_{i}$ and $v_{j}$ and $v_{k}$ be the failed nodes. We will prove the more interesting case for which $i<j<k<n-2$. First, by Claim 4, for $m\in[n-2]\setminus\{i,j,k\}$, $|N_{m}\cap(F_{i}\cup F_{j}\cup F_{k})|=3$, therefore each of the $n-5$ codewords ${\boldsymbol{c}}_{N_{m}}$, for $m\in[n-2]\setminus\{i,j,k\}$, is reconstructed with the decoder of the code ${\cal C}_{N}$. Next, the edges $(v_{i},v_{j}),(v_{j},v_{k}),(v_{i},v_{k})$ will be corrected with the code ${\cal C}_{\widetilde{P}_{3}}$. The word ${\boldsymbol{c}}_{\widetilde{P}_{3}}$ has three erasures in the indices $(i,j),(j,k),(i,k)$ and by Claim 3, the appropriate columns of ${\cal H}_{\widetilde{P}_{3}}$ are linearly independent. Therefore they are corrected with the decoder of the code ${\cal C}_{\widetilde{P}_{3}}$. Finally, the codewords ${\boldsymbol{c}}_{N_{i}},{\boldsymbol{c}}_{N_{j}}$ and ${\boldsymbol{c}}_{N_{k}}$ each has three missing edges $(v_{\ell},v_{\ell}),(v_{\ell},v_{n-2}),(v_{\ell},v_{n-1})$ where $\ell\in\{i,j,k\}$, and they are corrected with the decoder of ${\cal C}_{N}$. ∎

Lastly, we note that in this case we can also have a systematic construction of the codes in Construction 3.

V $(n-2)$-Node-Erasure-Correcting Codes

In this section we study $(n-2)$-node-erasure-correcting codes over $\mathbb{F}_{q}$. In particular, we will find necessary and sufficient conditions for the existence of optimal codes, and in case they exist we will find the number of such codes.

Every code over graphs ${\cal G}\textmd{-}[n,k_{\cal G}]_{q}$ can be represented by a generator matrix $\mathbf{G}$ of dimensions $k_{\cal G}\times\binom{n+1}{2}$ over $\mathbb{F}_{q}$. As done before we denote the columns of the generator matrix $\mathbf{G}$ by the indices of the set $\{(i,j)\in[n]^{2}\ |i\geqslant j\}$, in their lexicographic order, and so the column indexed by $(i,j)$ is represented by a vector ${\boldsymbol{g}}_{i,j}\in\mathbb{F}^{k_{\cal G}}_{q}$.

Lemma** 7**

. Let $\mathbf{G}$ be a generator matrix of a ${\cal G}\textmd{-}[n,3]_{q}$ code over graphs ${\cal C}_{{\cal G}}$. Then, ${\cal C}_{{\cal G}}$ is an optimal $(n-2)$-node-erasure-correcting code if and only if for all $i,j\in[n]$, the vectors ${\boldsymbol{g}}_{i,i},{\boldsymbol{g}}_{i,j}$ and ${\boldsymbol{g}}_{j,j}$ are linearly independent.

Proof:

Denote by $u_{0},u_{1},u_{2}$ the information symbols in $\mathbb{F}_{q}$ that are encoded with ${\cal C}_{{\cal G}}$. After a failure of $n-2$ nodes we will have two nodes $v_{i}$ and $v_{j}$ where $i,j\in[n]$, with three symbols on the edges that were not erased $c_{i,i},c_{i,j},c_{j,j}$. Finding the correct values of the information symbols $u_{0},u_{1},u_{2}$ can be achieved if and only if the equation system

[TABLE]

has a unique solution, that is, if and only if ${\boldsymbol{g}}_{i,i},{\boldsymbol{g}}_{i,j}$ and ${\boldsymbol{g}}_{j,j}$ are linearly independent. ∎

Lastly, we conclude with the following theorem.

Theorem** 8**

. For all positive integer $n\geqslant 3$ and prime power $q$, there exists an optimal $(n-2)$-node-erasure-correcting code over $\smash{\mathbb{F}_{\!q}}$ if and only if $\frac{q^{3}-1}{q-1}>n-1,$ and in this case, the number of such codes over graphs is

[TABLE]

Acknowledgments

The authors would like to thank Jehoshua Bruck for valuable discussions and Ron M. Roth for his contribution to the results in Section V and sharing reference [8] with them.