Lightweight FEC: Rectangular Codes with Minimum Feedback Information

TL;DR

This paper introduces a lightweight hybrid error correction protocol that minimizes feedback, reduces bandwidth, and efficiently repairs transmission errors over noisy channels, outperforming TCP in iteration reduction.

Contribution

It presents a novel rectangular error-correcting code combined with backward error correction, with a linear-time algorithm for minimal feedback, and analyzes its asymptotic bandwidth efficiency.

Findings

Reduces number of iterations by up to 40% compared to TCP.

Achieves asymptotically small backward channel bandwidth use.

Provides explicit asymptotic expansion for expected feedback bandwidth.

Abstract

We propose a hybrid protocol combining a rectangular error-correcting code - paired with an error-detecting code - and a backward error correction in order to send packages of information over a noisy channel. We depict a linear-time algorithm the receiver can use to determine the minimum amount of information to be requested from the sender in order to repair all transmission errors. Repairs may possibly occur over several cycles of emissions and requests. We show that the expected bandwidth use on the backward channel by our protocol is asymptotically small. In most configurations we give the explicit asymptotic expansion for said expectation. This is obtained by linking our problem to a well known algorithmic problem on a gadget graph, feedback edge set. The little use of the backward channel makes our protocol suitable where one could otherwise simply use backward error correction, e.g. TCP, but where overly using the backward channel is undesirable. We confront our protocol to numerical analysis versus TCP protocol. In most cases our protocol allows to reduce the number of iterations down to 60%, while requiring only negligibly more packages.

Equations

$$C_0:$$

$$C_1:$$

$$C_2:$$

$$C_3:$$

$$C_4:$$

$$C_5:$$

$${\overrightarrow{C}}_i:=\{\begin{array}{l}{\overrightarrow{X}}_i\text{if}0\le i<K\\ ⨁\{{\overrightarrow{X}}_k:\exists y,\varphi (k)=(i-K,y)\}\text{if}0\le i-K<n\\ ⨁\{{\overrightarrow{X}}_k:\exists x,\varphi (k)=(x,i-K-n)\}\text{if}0\le i-K-n<m\\ \underset{K\le k\le K+m}{⨁}{\overrightarrow{C}}_k\text{if}i=K+n+m\end{array}$$

$$I=N_e-R-C+N_{nscc}$$

$$\forall n_e\in {\mathbb{N}}_{N+1},\mathrm{Pr}(N_e=n_e)=\left(\genfrac{}{}{0ex}{}{N}{n_e}\right)\ast p^{n_e}\ast (1-p{)}^{N-n_e}$$

$$\forall n_e\in {\mathbb{N}}_{N+1},\mathbb{E}(N_e)=p\ast N$$

$$\forall j\in {\mathbb{N}}_{m+1},\mathrm{Pr}(C_j=0|N_e=n_e)=\frac{\left(\genfrac{}{}{0ex}{}{N-n-1}{n_e}\right)}{\left(\genfrac{}{}{0ex}{}{N}{n_e}\right)}$$

$$\forall k\in {\mathbb{N}}_{m+1},\mathrm{Pr}(C=k|N_e=n_e)=(\genfrac{}{}{0ex}{}{m+1}{k}){\left(1-\frac{\left(\genfrac{}{}{0ex}{}{N-n-1}{n_e}\right)}{\left(\genfrac{}{}{0ex}{}{N}{n_e}\right)}\right)}^k{\left(\frac{\left(\genfrac{}{}{0ex}{}{N-n-1}{n_e}\right)}{\left(\genfrac{}{}{0ex}{}{N}{n_e}\right)}\right)}^{m+1-k}$$

$$\mathbb{E}(C|N_e=n_e)=\sum _{j=0}^m\mathbb{E}(C_j|N_e=n_e)=(m+1)\ast \left(1-\frac{\left(\genfrac{}{}{0ex}{}{N-n-1}{n_e}\right)}{\left(\genfrac{}{}{0ex}{}{N}{n_e}\right)}\right)$$

$$\mathbb{E}(R|N_e=n_e)=(n+1)\ast \left(1-\frac{\left(\genfrac{}{}{0ex}{}{N-m-1}{n_e}\right)}{\left(\genfrac{}{}{0ex}{}{N}{n_e}\right)}\right)$$

$$I=N_e+N_{cc}-n-m-2$$

$$\mathrm{Pr}(N_{cc}=n+m+2-n_e|N_e=n_e)\to 1$$

$$\begin{gathered} \forall k\in [[0;n_e]],P(N_{cc}=n+m+2-n_e+k|N_e=n_e)\to \frac{{\lambda }^{k}exp(-\lambda )}{k!}, \\ where\lambda :=-\frac{ln(1-c)+c}{2} \end{gathered}$$

$$\mathrm{Pr}(N_{nscc}=1|N_e=n_e)\to 1$$

$$\mathbb{E}(I|N_e=n_e)\to 0$$

$$\mathbb{E}(I|N_e=n_e)\to -(ln(1-x)+x)/2$$

$$\mathbb{E}(I|N_e=n_e)=n_e+1-\frac{(m+1)\ast \left(\genfrac{}{}{0ex}{}{N-n-1}{n_e}\right)+(n+1)\ast \left(\genfrac{}{}{0ex}{}{N-m-1}{n_e}\right)}{\left(\genfrac{}{}{0ex}{}{N}{n_e}\right)}+o(1)$$

$$\mathbb{E}(I|N_e=n_e)\to 0$$

$$\mathbb{E}(I|N_e=n_e)\to \lambda (x)$$

$$\mathbb{E}(I|N_e=n_e)=n_e+1-2(n+1)\ast \frac{\left(\genfrac{}{}{0ex}{}{n^2+n}{n_e}\right)}{\left(\genfrac{}{}{0ex}{}{n^2+2n+1}{n_e}\right)}+o(1)$$

Full text

Introduction

Traditionally, forward error correction (FEC) is used to correct a limited amount of transmission errors over unidirectional channels, for example from an untrusted to a trusted network [1]. If the unidirectionality constraint can be relaxed, a small backward channel can allow the receiver to request additional information in order to correct more or even all of the transmission errors. This relaxation is even necessary if we wish to pass encrypted data, as in that case no amount of corruption, however small, is tolerable. However, for security reasons, it is important that use of this channel be confined to an absolute minimum.

Error correction over a noisy channel can also be achieved by automatic repeat request (ARQ). ARQ protocols require an error detector such as the user datagram protocol (UDP) and are based on an acknowledgement system: the sender re-emits each packet until the receiver acknowledges it has been received without errors. The main idea behind forward error correction is to use an error-correcting code to send redundant information over the channel in the hope that transmission errors will leave enough to retrieve the original message. Purely information re-emission based protocols can lead to a prohibitive number of cycles of exchanges between sender and receiver, especially if the round-trip time, a.k.a. the ping, is high. On the other hand, no protocol based solely on an error-correcting code can guarantee a reliable transmission: there is always a non-zero probability, growing with the channel’s bit error rate, that the message is not transmitted in full. Note that if the message is encrypted, then partial information is useless. Moreover, the redundant information can prove costly in bandwidth use. One solution is to combine backward and forward error correction in order to find a trade-off between transmission delay, success probability, and bandwidth use. Hybrid ARQ (HARQ) is based on this principle, and shows good results on sufficiently noisy channels ([3],[12],[8]).

In this paper, we propose a protocol combining a rectangular error-correcting code and backward error correction in order to send packets of information over an erasure channel. These packets are authenticated with the UDP protocol. Note that there are other error-correcting codes which do not use as much redundancy ([9],[4],[6],[2]), but our choice of rectangular codes is motivated by their structural simplicity. Indeed they can be seen as a system of equations, where the unknown variables correspond to the packets erroneously transmitted. It follows that a set of errors is repairable if and only if the unknown variables corresponding to erroneous packets can be eliminated one by one, i.e. the system of equations presents a form of acyclicity. We present a linear-time cycle-breaking algorithm the receiver can use to determine the minimum amount of information to be requested from the sender at the next iteration. This extra step reduces bandwidth use and the number of iterations. Numerical experiments of our protocol show a significant reduction in the number of iterations, $\approx 60\%$, of what is needed by the Transmission Control Protocol (TCP). Further, they show that the amount of information that goes from the sender to the receiver is asymptotically the same with or without the rectangular code: the redundancy introduced by the code is compensated by the minimality of the feedback requests. In a sense, our protocol condenses TCP into fewer iterations which suggests it could prove suited to transmissions in space, where round-trip time is high. Furthermore, computations are expensive for deep-space probes making the simplicity of rectangular codes all the more interesting.

The paper is organised as follows. [Section 1] defines the proposed protocol. [Section 2] studies two quality indicators of the protocol: the expected bandwidth use and the expected number of iterations, assuming transmission errors are distributed independently and with uniform probability. [Section 3] presents simulated experimental results and illustrates the results of [Section 2].

1 Rectangular codes with feedback

We denote by $\mathbb{N}_{n}$ the integer interval $[\![0;n[\![$. In this section we describe our hybrid forward error correction scheme. Suppose that we have a message $\mathcal{M}$, which we fix throughout this section, that the sender wishes to send to the receiver. The message is divided as an ordered sequence of $K$ bit vectors, all of the same size, where $K$ is a parameter of the protocol. For our protocol to work, the receiver must be able to determine which of the bit vectors were corrupted during transmission. Each of them is authenticated using the UDP protocol, and in particular the CRC-32 algorithm. Throughout this paper, we call packet such an authenticated bit vector, and denote by $(len)$ the common length of all packets of the message. In practice, it should be thought of as being of order at least $2^{10}$ – that is, the packets are of the order of 1 kB. We assume no packets are falsely flagged as correct. In the following, $\oplus$ denotes the binary bitwise-xor operator on bit vectors. When we say that we ‘sum’ -or ‘xor’- two packets, it should be understood that we perform a bitwise sum modulo two of the vectors of information embedded in the packets, dismissing the authentication bits, and then authenticate this new bit vector to obtain a packet. On a side note, the UDP protocol adds an index to each packet, which means packets in a single block can safely be received in any order.

1.1 Rectangular codes

A linear block code is an error-correcting code which acts on $K$ bits of input data to produce $N$ bits of output data $(N,K)$ via a linear transformation. The input and output of the codes we consider here are not single bits but vectors of fixed length $(len)$ called packets, so strictly speaking they are $(N*(len),K*(len))$ block codes. However, for simplicity we shall say that they act on $K$ packets to produce $N$ packets. Further, since the input data is embedded in the encoded output they are systematic codes. We will restrict our study to two-dimensional rectangular codes and we will therefore, for simplicity’s sake, only define rectangular codes in two dimensions.

Encoding Scheme

Informally, the encoding scheme works as follows. Place the $K=n*m$ input packets in a $n$ by $m$ rectangle (according to some ordering function which, along with $n$ and $m$ is a parameter of the problem), and add a parity check packet for each row and each column, obtained by summing all the packets in the hyperplane in question (either a row or a column). Finally, add an overall parity check packet obtained by summing all source packets, or equivalently by summing either all the row parity checks or all the column parity checks (cf Figure 1). Note that if the parity check packets are placed correctly (cf Figure 1), we get an $(n+1)$ by $(m+1)$ matrix where the packets in any given hyperplane (either a row or a column) sum to the zero vector. This will be the principle for decoding, but first we give a more formal definition of the encoding scheme.

These codes have linear time complexity: $O((2*K+min(m,n))*len)$ byte-xor are need for encoding and $O((2*K+m+n)*len)$ for decoding. The memory complexity for encoding and decoding is $O((m+n+1)*len)$.

Definition 1** (2D Rectangular Codes)**

Recall that we are working on packets of length $(len)$. Given a pair of dimensions $(n,m)\in\mathbb{N}^{*}\times\mathbb{N}^{*}$ and a bijective ordering function $\phi:\ \mathbb{N}_{n*m}\to\mathbb{N}_{n}\times\mathbb{N}_{m}$, the two-dimensional rectangular code with parameters $(n,m,\phi)$ is defined as follows: (where $K:=n*m$ and $N:=(n+1)*(m+1)$)

• •

It takes as input $\overrightarrow{X}_{0},\dots,\overrightarrow{X}_{K-1}\in\{0;1\}^{(len)}$

• •

It produces as output $\overrightarrow{C}_{0},\dots,\overrightarrow{C}_{N-1}\in\{0;1\}^{(len)}$, where:

[TABLE]

Note that if $n$ and $m$ are co-prime, then the ordering function $\phi$ defined by $\forall x\in\mathbb{N}_{n*m},\phi(x)=(x\mod n,x\mod m)$ is a practical choice which makes the computation of both $\phi$ and $\phi^{-1}$ easy. Note that $\phi$ is then indeed a bijection by the Chinese remainders theorem. Moreover, 2D rectangular codes take as input $K$ source packets, and add $M=N-K$ parity packets. In particular, they have rate $\frac{K*(len)}{N*(len)}=\frac{n}{n+1}*\frac{m}{m+1}$.

Decoding Scheme

Recall that if the source and parity check packets are placed in a $(n+1)$ by $(m+1)$ rectangular grid in the manner described in [Figure 1], it holds that the packets in any given row or column sum to zero. Therefore, if a packet is the only erroneous one in a row or column it may be repaired. This leads to a straightforward decoding algorithm:

Decoding Algorithm

Iteratively repair any error which is isolated in a row or column, until there are no errors left or none of them is isolated. Two examples of this iterative algorithm are given in [Figure 2]: one leads to a successful decoding, the other to a failure, due to what is called a Stopping Set.

Error Configurations

Define an error configuration as a set of packets erroneously transmitted. It is not always possible to repair all errors in a given configuration by inferring the erroneous packets from the correct ones without any additional information, which leads us to further characterise configurations as ‘Good’, ‘Bad’, or ‘Minimal Bad’. A good configuration (GC) is a set of errors (possibly empty) that can be completely repaired by the decoding algorithm, a bad configuration (BC) is a set of errors that cannot be completely repaired, and a minimal bad configuration (MBC) is a non-empty set of errors where no error can be repaired. See [Figure 3] for an illustration.

Feedback Repair

Suppose that we have a bad configuration, and that we can repair erroneous packets by requesting them anew from the sender, and no longer only by inferring them from the correct ones. Assuming we have a cost function assigning to each packet a positive cost of repair, the cost of repairing a set of erroneous packets is defined as the sum of the costs of its elements. For a given configuration we define a feedback repair set as a subset of errors whose removal yields a good configuration. Note that since we require the costs of repair to be positive, the only minimum feedback repair set of a good configuration is the empty set, of cost nil.

MinimumFeedbackRepairSet (MinFRS):

Input: $\mathcal{E}$ an error configuration and $w:\mathcal{E}\rightarrow\mathbb{R_{+}^{*}}$ a cost function.

Output: A set of errors $\mathcal{E}^{\prime}\subseteq\mathcal{E}$ of minimum cost such that $\mathcal{E}\backslash\mathcal{E}^{\prime}$ is a good configuration.

MinimumRepair (MR):

Input: $\mathcal{E}$ an error configuration and $w:\mathcal{E}\rightarrow\mathbb{R_{+}^{*}}$ a cost function.

Output: The cost of a minimum feedback repair set.

We use three different cost functions. The first is the all-or-none cost function, which assigns cost one to each and every packet. It is used when requested packets must be re-transmitted in full from the sender to the receiver. The second, which is a slight variation of the first one, is the modified-all-or-none cost function, which assigns cost one to the $\overrightarrow{C}_{k}$ for $k\geq K$, and cost $1+\frac{1}{N+1}$ to the $\overrightarrow{C}_{k}$ for $k<K$. We can use this if we prefer to request sources over parity check packets. The third is the graded cost function where the cost of a packet is equal to the number of corrupted bits. This last function is used when we allow the receiver to request only portions of packets from the sender.

For a given cost function, two questions arise related to random error configurations.

First Question: What is the expected amount of additional information needed to repair a random error configuration? 2. 2.

Second Question: With what probability is no additional information needed to repair a random error configuration? In other words, with what probability is a random error configuration a good one?

1.2 Protocol: emission-repair cycle on data streams

In this section, we define a protocol based on iterative cycles of emissions and repairs to transmit packets data over a noisy channel. The protocol uses any black-box linear error-correcting code, but in this paper we will only use rectangular codes.

More specifically, suppose that at a given iteration we want to encode $K$ packets of data. The optimal choice of parameters $n$ and $m$ for the rectangular code is a delicate question. In order to encode the packets, we need $n\times m$ to be no smaller than $K$, and if it is greater one can pad the $n$ by $m$ rectangle by repeating some of the $K$ packets. The two-dimensional rectangular codes which minimises the rate are the square ones, i.e. those where $n=m$. So if $K$ is a perfect square, then $(\sqrt{K},\sqrt{K})$ is a good choice of parameters. If not, the problem is to achieve a satisfying trade-off between minimising the two differences $|n-m|$ and $|n*m-K|$. We do not address this problem in this paper, however, and leave open the choice of rectangular codes.

A single cycle on a single block

We start by describing the basic building blocks of our protocol: the emission-request cycles. Suppose we have a single block of $K$ packets of input data that we want to transmit over a noisy channel. The sender encodes the input using the black-box code, and sends the yielded code packets over the channel. The receiver then determines a minimum feedback repair set, and sends the list of the indices of the packets in the FRS to the sender using a secondary channel. This return transmission consists only of a fairly short list of integers so it is reasonable to assume that the feedback channel is error-free.

Many cycles on a single block

Suppose we have a single block of $K$ packets of input data that we want to transmit over a noisy channel. Perform the emission-request cycle described above. The sender now holds a list of indices corresponding to a minimum FRS of the last emission. Denote by $k$ the size of the FRS. There are two possibilities: either encoding the $k$ packets requested using the black-box code yields less packets than the previous encoding of the $K$ did, or it does not. If it does, treat the $k$ packets of the FRS as the input of a new emission-request cycle. If it does not, repeat the previous emission of the $K$ packets. Note that in the latter case, the receiver determines a FRS to request based on the information received both during the previous emission and the last one. This is done in order to avoid having potentially larger and larger transmissions. Also note that if we use an $n$ by $m$ rectangular code to encode $K=n*m$ packets, then the maximum size of a minFRS over all error configurations is $k_{max}=(n+1)*(m+1)-((n+1)+(m+1)-1)=K$ and further this bound is only achieved when all of the $K$ packets are erroneous (by [Main Theorem 1]), so in this particular case we can always treat the FRS as input for a new emission-request cycle.

Repeat this process while the receiver requests non-empty feedback repair sets. This process may not terminate, but if it does the receiver can retrieve the whole original block of $K$ packets by iteratively using the feedback repair sets from last to first to retrieve the first FRS, and therefore the original transmission.

Many cycles on data streams

Suppose we have a message containing many packets of input data that we want to transmit over a noisy channel. Take a first block of $K$ packets. Perform a single emission-repair cycle, and denote by $k$ the size of the requested FRS. Add the next $(K-k)$ packets of the message to the packets of the previous FRS and perform a single emission-repair cycle. Repeat this process until there are not enough packets remaining to form a block of size $K$.

Send these remaining packets using the ‘Many cycles on a single block’ protocol described above. If this last protocol terminates, the receiver can retrieve the whole message by iteratively using the feedback repair sets from last to first to retrieve the first FRS, and therefore the original transmission.

Memory considerations

It is inadvisable to store too much information in the sender and receiver’s respective buffers, and should forget unnecessary information. At the end of an emission-request cycle, the sender can forget all the packets in the block apart from those in the FRS that the receiver just requested, as they will never appear in any subsequent FRS. Also, in the all-or-none repair model, once the receiver determines the list of indices of an FRS and sends it to the the sender, it can forget all the unrepaired erroneous packets it just received. Indeed, erroneous packets are repaired using only the information contained in the correct packets.

2 Performance Analysis – A Single Iteration

We assume that all packets are erroneous independently and with same probability $p$. Note that if $p_{b}$ is the bit error probability, then $p=1-(1-p_{b})^{(len)}$ and so $p\approx p_{b}\times(len)$ for small $p_{b}$ and large $(len)$. The probability $p$ should be thought of as ‘somewhat large’ (i.e. $p\in[0.2;0.8]$).

We wish to study the error configurations that we obtain by passing our message through the communication channel once using a rectangular code. Our sample space is $\mathcal{P}(\{\overrightarrow{C}_{i}:i\in\mathbb{N}_{N}\})$ with $\forall\mathcal{E}\subseteq\{\overrightarrow{C}_{i}:i\in\mathbb{N}_{N}\},\Pr(\mathcal{E})=p^{|\mathcal{E}|}(1-p)^{N-|\mathcal{E}|}$. For all $k\in\mathbb{N}_{N}$, define an indicator random variable $X_{i}$ associated with the packet $\overrightarrow{C}_{k}$ being erroneous. Let $N_{e}$ be the random variable whose value equals the number of erroneous packets, so that $N_{e}=\sum_{k=0}^{N-1}X_{k}$. The $(X_{k})_{0\leq k<N}$ are independent and identically distributed according to a Bernouilli distribution with same parameter $p$, hence $N_{e}$ follows a binomial distribution of parameters $N$ and $p$. Further define indicator variables $R_{i}$ for $i\in\mathbb{N}_{n+1}$ and $C_{j}$ for $j\in\mathbb{N}_{m+1}$ associated respectively with there being an erroneous packet on the $i^{th}$ row and in the $j^{th}$ column. Let then $R$ and $C$ be the random variables denoting the total number of rows and columns respectively containing at least one erroneous packet, so that $R=\sum_{i=0}^{n}R_{i}$ and $C=\sum_{j=0}^{m}C_{j}$. Now consider the binary relation $\sim\subseteq\{\overrightarrow{C}_{k},k\in\mathbb{N}_{N}:X_{k}=1\}^{2}$ defined by: $\overrightarrow{C}_{i}\sim\overrightarrow{C}_{j}$ ($i\neq j$) if and only if they are on the same row or in the same column when placed in the manner described in [Figure 1]. Let $N_{cc}$ and $N_{nscc}$ be the random variables equal to the number of equivalence classes of respectively its reflexive, symmetric, and transitive closure $\sim^{*}$ and its symmetric and transitive closure $\sim^{+}$. Finally, let $I$ be the random variable equal to the minimum repair cost of configuration $\mathcal{E}$. Note that $N_{e}$, the $C_{j}$, the $R_{i}$, $C$, $R$, $N_{cc}$, $N_{nscc}$, and $I$ are all deterministic functions of the family $(X_{k})_{0\leq k<N}$, which therefore stores all of the system’s randomness.

Theorem 1** (Main Theorem)**

Let $\mathcal{E}$ be a random error configuration. If the cost function for repairs is the all-or-none one, then there is an algorithm in $O(K)$ to find a minimum feedback repair set and furthermore: *

[TABLE]

*If the cost function for repairs is arbitrary, then there is a an algorithm in $O(K+|\mathcal{E}|*log(|\mathcal{E}|))=O(K*log(K))$ to find a minimum feedback repair set.

---

Proof. In the sequel, we address loopless simple undirected graphs. For a graph $G=(V,E)$, if $V^{\prime}\subseteq V$ and $E^{\prime}\subseteq E$, then $G[V^{\prime}]$ denotes the (vertex) induced subgraph of $G$ -i.e. the graph $(V^{\prime},E\cap(V^{\prime})^{2})$- and $G_{|E^{\prime}}$ denotes the (edge) partial graph induced by $E^{\prime}$ -i.e. the graph $(V,E^{\prime})$.

Assume for now that the cost function is arbitrary. Let us start by giving a sketch of the proof. First, we define a gadget that we call the coordinates’ graph, where the edges are labelled by the packets $(\overrightarrow{C}_{k})_{0\leq K<N}$. We can then define the partial graph induced by an error configuration as the graph where we keep only the edges labelled by an erroneous packet. We show that for a given error configuration, feedback repair sets are exactly feedback edge sets in this partial graph. Finally, we use the fact that the partial graph induced by the complement of a feedback edge set is a forest to prove [Theorem 1].

The gadget: Place the packets in an $(n+1)$ by $(m+1)$ grid in the manner described in [Figure 1]. Define the coordinates’ graph $\mathcal{G}$ as the complete bipartite graph with $(n+1)$ vertices $(\mathcal{R}_{i})_{0\leq i\leq n}$ corresponding to the rows on one side and $(m+1)$ vertices $(\mathcal{C}_{j})_{0\leq i\leq m}$ corresponding to the columns on the other. For every pair $(i,j)$, label edge $(\mathcal{R}_{i},\mathcal{C}_{j})$ by the packet place at coordinates $(i,j)$ in the rectangular grid. Finally assign to each edge the weight given by the cost function. See [Figure 5] and [Figure 6] for different illustrations of this definition. Note that this gadget can be constructed in time $O(K+|\mathcal{E}|)=O(K)$.

For a given graph, we define a feedback edge set as a subset of edges whose removal yields a good configuration.

MinimumFeedbackEdgeSet (MinFES):

Input: $G$ a weighted graph.

Output: A (possibly empty) set of edges of minimum weight whose removal breaks all cycles.

Having defined the gadget, we can begin the proof. Let $\mathcal{E}$ be an error configuration, and denote by $\mathcal{G}_{|\mathcal{E}}$ the partial subgraph of $\mathcal{G}$ induced by $\mathcal{E}$. The feedback repair sets of $\mathcal{E}$ are exactly the feedback edge sets of $\mathcal{G}_{|\mathcal{E}}$. Indeed, if $\mathcal{E}^{\prime}\subseteq\mathcal{E}$ then $\mathcal{E}^{\prime}$ is a FRS of $\mathcal{E}$ iff $\mathcal{E}\backslash\mathcal{E}^{\prime}$ is a GC, i.e. $\mathcal{E}\backslash\mathcal{E}^{\prime}$ is not a BC, i.e. every non-empty $\mathcal{E}^{\prime\prime}\subseteq\mathcal{E}\backslash\mathcal{E}^{\prime}$ can be reduced, i.e. there is no non-empty $\mathcal{E}^{\prime\prime}\subseteq\mathcal{E}\backslash\mathcal{E}^{\prime}$ containing no errors isolated in a row or column, i.e. there is no non-empty $\mathcal{E}^{\prime\prime}\subseteq\mathcal{E}\backslash\mathcal{E}^{\prime}$ such that $\mathcal{G}_{|\mathcal{E}^{\prime\prime}}$ has no vertex of degree one, i.e. there is no non-empty $\mathcal{E}^{\prime\prime}\subseteq\mathcal{E}\backslash\mathcal{E}^{\prime}$ such that $\mathcal{G}_{|\mathcal{E}^{\prime\prime}}$ has minimal degree two, i.e. there is no $\mathcal{E}^{\prime\prime}\subseteq\mathcal{E}\backslash\mathcal{E}^{\prime}$ such that $\mathcal{G}_{|\mathcal{E}^{\prime\prime}}$ is cyclic, i.e. $\mathcal{E}\backslash\mathcal{E}^{\prime}$ is acyclic, i.e. $\mathcal{E}^{\prime}$ is a FES of $\mathcal{G}_{|\mathcal{E}}$. In particular, the minimum feedback repair sets of $\mathcal{E}$ are exactly the minimum feedback edge sets of $\mathcal{G}_{|\mathcal{E}}$. Therefore, the complement of a minimum FRS is a maximum forest.

In a simple, undirected, unweighted graph, a maximum forest can be found in time $O(K)$ by a depth-first search: in each connected component, find a maximum spanning tree by arbitrarily selecting the root and then performing a depth first search, removing any backward edge encountered. Furthermore since a spanning forest has a number of edges equal to the number of vertices minus the number of connected components, we proved the part of the theorem pertaining to the all-or-none cost function.

In a simple, undirected, weighted graph, a maximum forest can be found in time $O(K+|\mathcal{E}|*log(|\mathcal{E}|))$ with Kruskal’s algorithm (see [5]). This proves the part of the theorem pertaining to an arbitrary cost function. $\Box$

Note that in the course of the proof, we also proved the following intermediate result which we will use again later.

Lemma 1

Let $\mathcal{E}$ be an error configuration. $\mathcal{E}$ is a good  configuration if and only if $\mathcal{G}_{|\mathcal{E}}$ is acyclic.**

Having established this, we can compute various indicators of the quality of our protocole. Ideally, we would like to determine the law of $I$, as well as the conditional distribution of $I$ given $N_{e}$. Note that this can be done in simple exponential time by exploiting the expression given in [Theorem 1]. Two simpler problems however are that of computing the conditional expectation instead of the conditional probability, and that of computing the conditional probability that $I=0$ given $N_{e}$. $\mathbb{E}(I|N_{e}=n_{e})$ can be seen as the expected bandwidth use on the backward channel, and $\Pr(I=0|N_{e}=n_{e})$ can be seen as the probability of successfully decoding the input data if we do not allow a backward channel. We choose to condition by the event ‘$N_{e}=n_{e}$’ as this provides a finer-grained analysis: the performances of our protocol are averaged not over all error configurations, but over all error configurations of a given size. The law of total probability combined with [Equation 2] can however provide $\mathbb{E}(I)$ and $\Pr(I=0)$.

2.1 Preliminary computations

Recall that $N$, $K$, $m$, $n$, $p$ are constants while $(X_{k})_{k}$, $N_{e}$, $(C_{j})_{j}$, $C$, $(R_{i})_{i}$, $R$, $N_{cc}$, $N_{nscc}$, $I$ are random variables.

Study of $N_{e}$

Recall that $N_{e}$ is the random variable equal to the number of errors, and that it follows a binomial distribution of parameters $N$ and $p$. Hence, we have the following:

[TABLE]

[TABLE]

Study of $C$ and $R$ knowing $N_{e}$

Recall that $C$ is the random variable equal to the number of columns containing at least one error, and that $C_{j}$ ($j\in\mathbb{N}_{m+1}$) is the indicator random variable corresponding to there being an error in the $j^{th}$ column.

Suppose we know that there are exactly $n_{e}$ errors (i.e. we condition by the event ‘$N_{e}=n_{e}$’), then the probabilistic setting is exactly that of throwing $n_{e}$ undistinguishable balls in $(m+1)$ distinguishable bins of maximum capacity $(n+1)$ each. Notice that the complementary event of ‘$C_{j}=0$’ is ‘all errors occur in the $m$ other columns’, i.e. in a specific area of the integral grid composed of $(N-n-1)$ points. From this, and the fact that errors occur uniformly, we get the conditional law of $C_{j}$ knowing $N_{e}$:

[TABLE]

This in turn yields the conditional law of $C$ knowing $N_{e}$, as well as the conditional expectancy of $C$ knowing $N_{e}$ (by linearity of the expectation for instance):

[TABLE]

[TABLE]

And similarly, for the rows we obtain the following equation:

[TABLE]

Study of $N_{cc}$ and $N_{nscc}$ knowing $N_{e}$

Notice that for a random error configuration $\mathcal{E}$, $N_{cc}$ can be seen as the number of connected components of $\mathcal{G}_{|{\mathcal{E}}}$, and $N_{nscc}$ as the number of non-singleton connected components. It follows that $N_{cc}=N_{nscc}+(n+1-R)+(m+1-C)$. The expression of $I$ given in [Theorem 1] can thus be reformulated as follows:

[TABLE]

The following theorems are due to respectively Kalugin and Saltykov, and may be found in [7] and [10] (up to the notations).

Theorem 2** (Kalugin (’94))**

As ${n,m,n_{e}\to\infty}$,

• •

if $\frac{n_{e}^{2}}{(n+1)(m+1)}\to 0$, then:

[TABLE]

• •

if $n_{e}=\Theta(n)$, $n_{e}=\Theta(m)$, and $\frac{n_{e}^{2}}{(n+1)(m+1)}\to c\in]0;1[$, then:

[TABLE]

Theorem 3** (Saltykov (’95))**

Assume without loss of generality that $m\geq n$. As ${(n+m)\to\infty}$, if $n_{e}=(n+1)*ln(n+m)+O(n)$, then:

[TABLE]

2.2 Expected bandwidth use: $\mathbb{E}(I|N_{e}=n_{e})$

Having done all the preliminary computations, we can now compute the first quality indicator of our protocol: the expected number of packets requested by the receiver after a single transmission containing exactly $n_{e}$ errors.

Theorem 4** (Expected bandwidth use – known number of errors)**

Assume without loss of generality that $m\geq n$. As ${n,m,n_{e}\to\infty}$,

• •

if $n_{e}^{2}=o(nm)$, then:

[TABLE]

• •

if $n_{e}=\Theta(n)$, $n_{e}=\Theta(m)$, and $\frac{n_{e}^{2}}{(n+1)(m+1)}\to x\in]0;1[$, then:

[TABLE]

• •

if $n_{e}=(n+1)*ln(n+m)+O(n)$, then:

[TABLE]

Proof.  [Eq. 12] is obtained by combining [Eq. 8 and 9], [Eq. 13] is obtained by combining [Eq. 8 and 10], and [Eq. 14] is obtained by combining [Eq. 1, 6, 7, and 11]. $\Box$

Corollary 1

Assume that $n=m$. As $n\to\infty$,

• •

if $n_{e}=o(n)$, then:

[TABLE]

• •

if $n_{e}=\Theta(n)$, and $\frac{n_{e}}{n}\to x\in]0;1[$, then:

[TABLE]

where $\lambda(x)=-(ln(1-x)+x)/2\in]0;1[$

• •

if $n_{e}=n*ln(n)+O(n)$, then:

[TABLE]

2.3 Probability of successfully decoding without a backward channel: $\Pr(I=0|N_{e}=n_{e})$

Recall from [Lemma 1] that an error configuration $\mathcal{E}$ is good, i.e. $I=0$, if and only if $\mathcal{G}_{|\mathcal{E}}$ is acyclic. It follows that $\Pr(I=0|N_{e}=n_{e})=f(n,m,n_{e})/{N\choose n_{e}}$, where $f(n,m,n_{e})$ is the number of partial subgraphs with $n_{e}$ edges of the labelled complete bipartite graph $K_{n,m}$. In [11], Stones provides an exponential time algorithm to compute $f$.

3 Experimental Results – Many Cycles

3.1 Many cycles on a single block

In this section we present experimental results and focus on two quality indicators of the ‘Many cycles on a single block’ protocol: the average number of iterations and of packages transmitted before the message is received in full by the receiver. We compare these to the TCP protocol, with no forward error correction used.

Define the efficiency $e_{K}$ of the ‘many cycles on a single block of size $K$’ protocol as the number of packages sent by the sender over all iterations divided by the number of packages transmitted (i.e. $K$). Note that $e_{K}\geq 1$. We plot $e_{K}$ for $K\in\{256,1024,4096,16385,65536\}$ in [Figure 9] as functions of $p$. We would like this value to be the nearest possible to 1. [Figure 9] shows that for $p=0$, every packet is received, so we have $e_{K}=\frac{(m+1)*(n+1)}{K}\longrightarrow 1+2\sqrt{K}$, whereas for greater values of $p$, $e_{K}\longrightarrow 1$. To reduce this value, we could consider another strategy: we could send only the $K$ source packets at the first iteration, and send some code packets at the second iteration, if needed. This way, we would decrease the average number of packets sent, but we would increase the average number of iterations required, which is what we try to avoid.

Define $i_{K}$ as the average number of iterations before the ‘many cycles on a single block of size $K$’ protocol terminates. We plot $i_{K}$ for $K\in\{16,64,256\}$ in [Figure 7]. For example, sending 256 packets with TCP protocol over a channel with an erasure probability $p=0.3$ will require about 6 iterations, whereas it requires approximately 3 iterations with our protocol. [Figure 8] shows the average gain in terms of number of iterations between our protocol and the TCP protocol. For $K=16$, our protocol requires approximately $60\%$ less iterations than TCP, for $K=256$ it requires $50\%$ less iterations, and for $K=65536$, it requires approximately $25\%$ less iterations. As for the H-ARQ protocol, if $p$ is great enough for the code to be useful (i.e: we lose at least one packet at the first iteration), we can observe an improvement in terms of iterations.

These experimental results were obtained as follows. For each value of $K$, the protocol was run $10^{5}$ times, each time with an erasure probability $p$ taken uniformly at random in the interval $]0;1[$. Recall from [Section 1.2], that the choice of parameters $n$ and $m$ at a given iteration is problematic. These results were obtained by ‘padding with zeros’: $n$ and $m$ are chosen equal and minimal such that $n^{2}\geq K$. $(n^{2}-K)$ empty packages (ie. $(0,\dots,0)$) are added to complete the square code, but are never sent.

4 Conclusion

The heart of the protocol presented in this paper is the minimality of feedback information. What we require from the ECC is that there exists an efficient algorithm to determine a minFRS. Potential candidates for the ECC could be higher dimensional rectangular codes, however no minimum feedback algorithm is known to us. The error-detecting scheme can be changed too: we can use a minimal distance separable ECC instead of the UDP protocol to generate authenticated packets, which then have a chance of ‘repairing themselves’.

As it stands, using two dimensional rectangular codes, our protocol presents two potential use-cases directly linked to the minimality of the feedback information requests:

• •

Minimally bidirectional channels: Data diodes are used in guaranteeing information security, but strictly unidirectional channels cannot achieve zero-error transmissions. Our hybrid protocol however can, and limits bidirectionality to what is necessary. Further, all computations (encoding, feedback information determination, and decoding) are sufficiently light to be performed by hardware inside the data diode.

• •

Reducing round-trip time: Our protocol can be seen as an ‘improved TCP’ since the addition of an error-correcting code reduces transmission time.