Index Coding with Multiple Interpretations

Abstract

The index coding problem consists of a system with a server and multiple receivers with different side information and demand sets, connected by a noiseless broadcast channel. The server knows the side information available to the receivers. The objective is to design an encoding scheme that enables all receivers to decode their demanded messages with a minimum number of transmissions, referred to as an index code length. The problem of finding the minimum length index code that enables all receivers to correct a specific number of errors has also been studied. This work establishes a connection between index coding and error-correcting codes with multiple interpretations from the tree construction of nested cyclic codes. The notion of multiple interpretations using nested codes is as follows: different data packets are independently encoded, and then combined by addition and transmitted as a single codeword, minimizing the number of channel uses and offering error protection. The resulting packet can be decoded and interpreted in different ways, increasing the error correction capability, depending on the amount of side information available at each receiver. Motivating applications are network downlink transmissions, information retrieval from datacenters, cache management, and sensor networks.

1. Introduction

In this work, we consider a source code variant, introduced by Birk and Kol [1], originally called informed source coding-on-demand (ISCOD), and further developed by Bar-Yossef et al. [2]. Motivating applications include satellite transmission of large files, audio and video on demand (such as streaming networks), database data retrieval, cache management for network applications and sensor networks. The model considered in [1] involves a source that possesses n messages and m receivers. Each receiver knows a proper subset of messages, which is referred to as the side information and demands a specific message unknown to it. The source, aware of the messages possessed by each receiver, uses this knowledge to develop a transmission scheme that satisfies the demands of all receivers using as few transmissions as possible, referred to as the index code length.

Index coding can be viewed as special case of rate distortion with multiple receivers, each with some side information about the source [3]. Index coding has received considerable attention recently, motivated by applications in multi-user broadcast scenarios, such as audio and video on demand, streaming networks, satellite communications and by its connection to network coding. In [4,5], the equivalence between network encoding and index encoding has been established. This research topic has been extended in other directions, such as pliable index coding [6], a variation of index coding in which we still consider a server and m clients with side information, but where the receivers are flexible and satisfied to receive any message that is not in their side information set; such flexibility can reduce the amount of communication, sometimes significantly. This has applications in music streaming services or internet searching, such as content distribution networks (CDNs) [7]; a CDN manages servers in multiple geographically distributed locations, stores copies of the web content (including documents, images, audio and others) in its servers and attempts to direct each user request to a CDN location that will provide the best user experience. In this application, each receiver may be interested in receiving any message that it does not already possess as side information. Suppose that we are searching for the latest news and we already have some information. We are happy if we obtain any additional news that we do not have, with minimum delay. Here, we do not specify the news. On a music streaming service, users do not know which song will play next; they are usually only guaranteed that it will be one of a certain group and that it will not be repeated. In online advertising systems, customers do not require a specific advertisement to view; it is the distributor who chooses which one will be placed on customers’ screens. The distributor may wish to avoid repeating the same advertisement for the same customer, as this can decrease customer satisfaction.

How much we can gain in terms of bandwidth and user satisfaction, if recommendation systems become bandwidth-aware and take into account not only the user preferences? Song and Fragouli [8] formulated this as a new problem in the context of index coding, where they relaxed the index coding requirements and considered the case where the customer is satisfied to receive any message that they do not already have, with satisfaction proportional to their preference for that message.

A promising research area that has recently emerged is in how to use index coding to improve the communication efficiency in distributed computing systems, especially for data shuffling in iterative computations [9,10]. Index coding has been proposed to increase the efficiency of data shuffling, which can form a major communication bottleneck for big data applications. In particular, pliable index coding can offer a more efficient framework for data shuffling, as it can better leverage the many possible shuffling choices to reduce the number of transmissions.

The index coding problem subject to transmission errors was initially considered by Dau et al. [11]. In this work, we establish a connection between index coding and error-correcting codes with multiple interpretations from the tree construction of nested cyclic codes proposed in [12]. The notion of multiple interpretation using nested codes [13] is as follows: multiple information packets are separately encoded via linear channel codes, and then combined by addition and transmitted as a single codeword, minimizing the number of channel uses and offering error protection. The resulting packet can be decoded and interpreted in different ways, yielding an increase in error correction capability, depending on the amount of side information available at each receiver.

Part of the content of this paper was presented in [14]. In the current version, evidence to verify our claims has been added, as well as some examples. The results in this paper are an extension of the results in [12,14].

The main contributions of this paper are as follows.

• We verify that, for cyclic codes, there will not always be an increase in error correction capability between different levels of the code tree. For this reason, we initially restrict the study to Reed–Solomon codes since they are maximum separable distance (MDS) codes, and provide an increase in Hamming distance at each level. This means that, under certain conditions, knowledge of side information can be interpreted as an increase in error correction capability.
• We propose a new variant for the index coding problem, which we call “index coding with multiple interpretations”. We assume that receivers demand all the messages from the source and that the sender is unaware of the subset of messages already known by the receivers. The sender performs encoding such that any side information may be used by the decoder in order to increase its error correction capability. Moreover, if a receiver has no side information, the decoder considers the received word to belong to the highest rate code, associated with the root node of the tree.
• We also propose a solution to relax some constraints on how side information should occur at the receivers, using graph coloring associated with the pliable index coding problem.

2. Preliminaries

2.1. Notation and Definitions

For any positive integer n, we let $\left[n\right]:=\{1,\dots ,n\}$. We write ${\mathbb{F}}_q$ to denote the finite field of size q, where q is a prime power, and use ${{\mathbb{F}}_q}^{n\times t}$ to denote the vector space of all $n\times t$ matrices over ${\mathbb{F}}_q$.

2.2. Review of Linear and Cyclic Codes

We now introduce the notation and briefly review some of the relevant properties of linear and cyclic codes based on [15,16]. The purpose of a code is to add extra check symbols to the data symbols so that errors may be found and corrected at the receiver. That is, a sequence of data symbols is represented by some longer sequence of symbols with enough redundancy to protect the data. In general, to design coding schemes for receivers with side information, we will consider collections of linear codes that are of length n over ${\mathbb{F}}_q$.

Structure of Linear Block Codes

Recall that under componentwise vector addition and componentwise scalar multiplication, the set of n-tuples of elements from ${\mathbb{F}}_q$ is the vector space called ${\mathbb{F}}_q^n$. For the vectors $u=(u_1,\dots ,u_n)\in {\mathbb{F}}_q^n$ and $v=(v_1,\dots ,v_n)\in {\mathbb{F}}_q^n$, the Hamming distance between u and v is defined to be the number of coordinates u and v that differ, i.e.,

$$d(u,v)=\left|\right\{i\in \left[n\right]:u_i\ne v_i\left\}\right|.$$

Definition 1.

A k-dimensional subspace $\mathcal{C}$ of ${\mathbb{F}}_q^n$ is called a linear ${(n,k,d)}_q$ code over ${\mathbb{F}}_q$ if the minimum distance of $\mathcal{C}$,

$$d\left(\mathcal{C}\right)\triangleq \underset{u,v\in \mathcal{C},u\ne v}{min}d(u,v)$$

is equal to d. Sometimes, we only use ${(n,k)}_q$ to refer to the code $\mathcal{C}$, where n is the length of the codewords and k is the dimension of the code. The code’s rate is the ratio ${\displaystyle \frac{k}{n}}$.

That is, a ${(n,k)}_q$ linear code $\mathcal{C}$ can be completely described by any set of k linearly independent codewords $v_1,v_2,\dots ,v_k$; thus, any codeword is one of the $q^k$ linear combinations ${\sum }_{i_1}^k{\alpha }_i{v}_i$, ${\alpha }_i\in {\mathbb{F}}_q$. If we arrange the codewords into a $k\times n$ matrix G, we say that G is a generator matrix for $\mathcal{C}$.

A special case of major importance is ${\mathbb{F}}_2^n$, which is the vector space of all binary codewords of length n with two such vectors added by modulo-2 addition in each component. A binary code of size $M=2^k$ for an integer k is referred to as an $(n,k)$ binary code.

We consider cyclic codes of length n over ${\mathbb{F}}_q$ with $gcd(n,q)=1$. Label the coordinates of $c\in {\mathbb{F}}_q^n$ with the elements of ${\mathbb{Z}}_n=\{0,1\dots ,n-1\}$ and associate the vector $c=(c_0,\dots ,c_{n-1})$ with the polynomial $c\left(x\right)=c_0+c_{1}x+\cdots +c_{n-1}{x}^{n-1}$. With this correspondence, a cyclic code $\mathcal{C}$ is an ideal of the ring $R_n={\mathbb{F}}_q\left[x\right]/(x^n-1)$. We use $g\left(x\right)$ to denote the generator polynomial of $\mathcal{C}$ and write $\mathcal{C}=\langle g\left(x\right)\rangle =\{C\left(x\right)\in F_q\left[x\right];g\left(x\right)|C\left(x\right)\}$ to describe a t-error correcting cyclic code.

2.3. Index Coding with Side Information

The system shown in Figure 1 illustrates the index coding problem. Receiver $R_i$ is requesting the message $x_i$, $i\in \{1,2,3\}$ and knows other messages as side information; $R_1$ knows $x_3$, $R_2$ knows $x_1$ and $x_3$ and the receiver $R_3$ knows $x_1$ and $x_2$.

The goal of index coding is to perform the joint encoding of the messages, in order to simultaneously meet the demands of all receivers, while transmitting the resulting messages at the highest possible rate.

Assuming a noiseless broadcast channel, the server would communicate all messages by sending one at a time, in three transmissions.

Alternatively, when transmitting the two coded messages $x_1$ and $x_2\oplus x_3$, the receiver $R_1$ decodes $x_1$, from $(x_2\oplus x_3)\oplus x_3=x_2$ and $(x_2\oplus x_3)\oplus x_2=x_3$, $R_2$ and $R_3$ recover their demands.

The index coding problem is formulated as follows. Suppose that a server S wants to send a vector $x=(x_1,x_2,\dots ,x_n)$, where $x_i\in {\mathbb{F}}_q\forall i\in \left[n\right]$, to $\left[n\right]$ receivers $R_1,R_2,\dots ,R_n$. Each receiver $R_i$ has ${\displaystyle x_{S_i}=\{x_j;j\in S_i\subseteq \left[n\right]\setminus \left\{i\right\}\}}$ as side information and is interested in receiving the message $x_i$. The codeword $\mathfrak{C}\left(x\right)\in {\mathbb{F}}_q^{\ell }$ is sent and allows each receiver $R_i$ to retrieve $x_i$. $\mathfrak{C}$ is an index code scalar over ${\mathbb{F}}_q$ of length ℓ. The purpose of S is to find an index code that has the minimum length. The index code is called linear if $\mathfrak{C}\left(x\right)$ is a linear function.

Index Coding via Fitting Matrices

A directed graph $\mathcal{G}=(\mathcal{V},\mathcal{E})$ with n vertices specifies an instance of the index coding problem. Each vertex of $\mathcal{G}$ corresponds to a receiver (and its demand) and there is a directed edge $i⟶j$ if and only if the receiver $R_i$ knows $x_j$ as side information. Then, we write:

$$S_i=\{j:(i,j)\mathrm{is}\mathrm{a}\mathrm{edge}\mathrm{of}\mathcal{G}\}$$

Definition 2.

Let $\mathcal{G}=(\mathcal{V},\mathcal{E})$ be a directed graph on n vertices without self-loops.

1.

A 0-1 matrix $M=\left(m_{ij}\right)$, whose rows and columns are labeled by the elements of $\mathcal{V}=\left[n\right]$, fits $\mathcal{G}$ if, for all i and j,

(i)

$m_{ii}=1$;

(ii)

For $i\ne j$,

$$m_{ij}=\left\{\begin{array}{cc}\ast \in \{0,1\};\hfill & if(i,j)isanedgeof\mathcal{G};\hfill \\ 0\hfill & ;else.\hfill \end{array}\right.$$

Thus, $M-I$ is the adjacency matrix of an edge-induced subgraph of $\mathcal{G}$, where I denotes the $n\times n$ identity matrix.

2.

The minrank of $\mathcal{G}$ over the field ${\mathbb{F}}_2$ is defined as follows:

$${minrk}_2\left(\mathcal{G}\right)\triangleq min\{{rank}_2\left(M\right):Mfits\mathcal{G}\}$$

Remark 1.

The term rank${}_2\left(M\right)$ denotes the rank of such matrix M over ${\mathbb{F}}_2$, after $“\ast ”$ has been assigned a value of 0 or 1. As an example for the index coding problem instance described in Figure 1, the matrix M would be given as follows:

$$M=\left[\begin{array}{ccc}1& 0& \ast \\ \ast & 1& \ast \\ \ast & \ast & 1\end{array}\right]$$

Example 1.

Consider the side information graph $\mathcal{G}$ and a matrix M that fits $\mathcal{G}$, as shown in Figure 2. As ${minrank}_2\left(M\right)=2$, we can select two linearly independent rows in a matrix M, namely $M^{\prime }$, and design an linear index code with the shortest possible length. The codeword sent will be $M^{\prime }x$.

Theorem 1

([2]). For any side information graph $\mathcal{G}$, there exists a linear index code for $\mathcal{G}$ whose length equals minrk${}_2\left(\mathcal{G}\right)$. This bound is optimal for all linear index codes $\mathcal{G}$.

In [17], the index encoding problem was generalized. Suppose that a sender wants to transmit n messages $(X_1,\dots ,X_n)$, where $X_i\in {{\mathbb{F}}_q}^t\forall i\in \left[n\right]$, to m receivers $R_1,\dots ,R_m$, through a noiseless channel. The receiver $R_j$ is interested in recovering a single block $X_{f\left(j\right)}$, where $f:\left[m\right]⟶\left[n\right]$, and knows ${\displaystyle X_{S_j}=\{X_i;i\in S_j\subseteq \left[n\right]\setminus f\left(j\right)\}}$. The goal is to satisfy the demands of all receivers, exploiting their side information in a minimum number of transmissions.

When $m=n$, $f\left(j\right)=j,\forall j\in \left[m\right]$ and $t=1$, we have a scalar index code [2]. Otherwise, we have a vector index code.

Let $\mathcal{I}=\{S_j;j\in \left[m\right]\}$ be the set of side information of all receivers. An instance of an index coding problem given by $(m,n,\mathcal{I},f)$ can be described by a directed hypergraph.

Definition 3.

The side information hypergraph $\mathcal{H}(\mathcal{V},{\mathcal{E}}_{\mathcal{H}})=\mathcal{H}(m,n,\mathcal{I},f)$ is defined by the set of vertices $\mathcal{V}=\left[n\right]$ and the (directed) hyperedges ${\mathcal{E}}_{\mathcal{H}}$, where

$${\mathcal{E}}_{\mathcal{H}}=\{e_j=(f\left(j\right),S_j);j\in \left[m\right]\}$$

A hyperedge $e_j=(f\left(j\right),S_j)$ represents the demand and side information of the receiver $R_j$.

Example 2.

Consider an instance of an index coding problem in Figure 3. The hypergraph in Figure 3b describes the problem, where $n=4$ (messages) and $m=5$ (receivers) requiring $f\left(1\right)=1$, $f\left(2\right)=3$, $f\left(3\right)=4$, $f\left(4\right)=4$ and $f\left(5\right)=2$, and with the following side information sets $S_1=\{3,4\},S_2=\{2,4\},S_3=\left\{1\right\}$, $S_4=\left\{2\right\}$ and $S_5=\{1,3\}$, respectively.

Definition 4.

Given an instance of an index encoding problem described by $\mathcal{H}(m,n,\mathcal{I},f)$,

$${\displaystyle \mathfrak{C}:{{\mathbb{F}}_q}^{n\times t}⟶{{\mathbb{F}}_q}^{\ell \times t},}$$

is a ${\mathbb{F}}_q$- index code with length ℓ, for the instance described by $\mathcal{F}$, if, for each receiver $R_j$, $j\in \left[m\right]$, there exists a decoding function

$${\displaystyle {\mathfrak{D}}_j:{{\mathbb{F}}_q}^{\ell \times t}\times {{\mathbb{F}}_q}^{t\mid S_j\mid }⟶{{\mathbb{F}}_q}^t,}$$

satisfying ${\mathfrak{D}}_j(\mathfrak{C}\left(X\right),X_{S_j})=X_{f\left(j\right)},\forall X\in {{\mathbb{F}}_q}^{n\times t}$.

The transmission rate of the code is defined as ${\displaystyle \frac{\ell }{t}}$. If $t=1$, then the index code is known as a scalar index code; otherwise, it is known as a vector index code. A linear coding function $\mathfrak{C}$ is also called a linear index code. The goal of index coding is to find optimal index codes, i.e., those with the minimum possible transmission rate. For scalar linear index codes, we refer to the quantity r as the length of the code, and thus rate optimality translates to minimal length codes.

Definition 5.

$\mathfrak{C}$ is a ${\mathbb{F}}_q$-linear index code, $\mathfrak{C}\left(X\right)=GX,\forall X\in {\mathbb{F}}_q^{\ell \times n}$, where $G\in {\mathbb{F}}_q^{\ell \times n}$. G is the matrix that generates the linear index code $\mathfrak{C}$.

The following definition generalizes the minrank definition over ${\mathbb{F}}_q$ of the side information graph $\mathcal{G}$, which was defined in [2], to a hypergraph $\mathcal{H}(m,n,\mathcal{I},f)$.

Definition 6.

Let Supp$\left(v\right)=\{i\in \left[n\right]:v_i\ne 0\}$, the support of a vector $v\in {\mathbb{F}}_q^n$. The Hamming weight of v will be denoted by $\omega \left(v\right)=\left|Supp\right(v\left)\right|$, the number of nonzero coordinates of v.

Definition 7

([11]). Suppose that $\mathcal{H}(m,n,\mathcal{I},f)$ corresponds to an instance of index coding with side information (ICSI). Then, the minrank of $\mathcal{H}$ over ${\mathbb{F}}_q$ is defined as

$${minrk}_q\left(\mathcal{H}\right)\triangleq min\{{rank}_q\left({\{v_i+e_{f\left(i\right)}\}}_{i\in \left[m\right]}\right):v_i\in {\mathbb{F}}_{q}Supp\left(v_i\right)\subseteq S_i\}$$

This may be rewritten as follows.

Definition 8.

Let a side information hypergraph $\mathcal{H}$ correspond to an instance of the ICSI problem. A matrix $M=\left(m_{ij}\right)\in {\mathbb{F}}_q^{m\times n}$ fits $\mathcal{H}$ if

$$m_{ij}=\left\{\begin{array}{cc}1\hfill & ifj=f\left(i\right)\hfill \\ 0\hfill & ifj\in /S_i\hfill \end{array}\right.$$

The minrank of $\mathcal{F}$ over the field ${\mathbb{F}}_q$ is defined as follows:

$${minrk}_q\left(\mathcal{H}\right)\triangleq min\{{rank}_q\left(M\right):Mfits\mathcal{H}\}$$

Theorem 2

([2]). Given an instance of an index encoding problem described by the hypergraph $\mathcal{H}(m,n,\mathcal{I},f)$, the optimal length of an index code on the field ${\mathbb{F}}_q$ is ${minrk}_q\left(\mathcal{H}\right)$.

In [2], it was proven that, in several cases, linear index codes were optimal. They conjectured that for any side information graph $\mathcal{G}$, the shortest-length index code would always be linear and have length ${minrk}_2\left(\mathcal{G}\right)$. The conjecture was refuted by Lubetzky and Stav in [18]. In any case, as shown by Peeters [19], calculating the minrank of an arbitrary graph is a difficult task. More specifically, Peeters showed that deciding whether a graph has minrank three is an NP-complete problem.

Example 3.

Consider the instance of the index encoding problem given in Example 2. Then, we find that the matrix M that fits the hypergraph $\mathcal{H}$ has the form:

$$M=\left[\begin{array}{cccc}1& 0& \ast & \ast \\ 0& \ast & 1& \ast \\ \ast & 0& 0& 1\\ 0& \ast & 0& 1\\ \ast & 1& \ast & 0\end{array}\right]$$

The lines are associated with the receivers $R_1,\dots ,R_5$ and the columns to the message indexes $1,2,3$ and 4. The symbol $“\ast ”$ can be replaced by an arbitrary element in the field ${\mathbb{F}}_q$.

For an example, consider the field ${\mathbb{F}}_2$. A matrix that fits the hypergraph $\mathcal{H}$ has rank at least 3. Thus, we select

$$M=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 1& 0\\ 0& 0& 0& 1\\ 0& 0& 0& 1\\ 0& 1& 1& 0\end{array}\right]$$

which achieves the minimum rank 3. Now, we consider three linearly independent lines of M, and suppose that

$$G=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 1& 0\\ 0& 0& 0& 1\end{array}\right]\Rightarrow Gx=\left[\begin{array}{cccc}1& 0& 0& 0\\ 0& 1& 1& 0\\ 0& 0& 0& 1\end{array}\right]\left[\begin{array}{c}{x}_1\\ x_2\\ x_3\\ x_4\end{array}\right]=\left[\begin{array}{c}{x}_1\\ x_2\oplus x_3\\ x_4\end{array}\right]$$

The decoding process goes as follows. Since $R_2$ and $R_5$ already know $\{x_2,x_4\}$ and $\{x_1,x_3\}$, respectively, they obtain $x_3$ and $x_2$, respectively, from the first packet. Receiver $R_1$ obtains $x_1$ and both $R_3$ and $R_4$ obtain $x_4$.

Remark 2.

We have made available at [20] an algorithm (m-files) in Matlab, which is designed to solve small examples in this work, since, as we mentioned above, there is no polynomial-time algorithm for an arbitrary graph.

2.4. Pliable Index Coding

The pliable index coding problem (PICOD), introduced by Brahma and Fragouli in [6], is a variant of the index coding problem. In PICOD, users do not have predetermined messages to decode, as in the case of classic index coding; instead, each user is satisfied to decode any message that is not present in its side information set. Figure 4 illustrates this system model.

The problem is formalized as follows: a transmitter with n messages $\{x_i:i\in \left[n\right]\}$, $x_i\in \mathcal{X}$ is connected to m receivers $R_1,\dots ,R_m$, through a noiseless channel. Each receiver $R_j$ knows ${\displaystyle x_{S_j}=\{x_i:i\in S_j\}}$ as side information. We denote by $I_j\triangleq \left[n\right]\setminus S_j$ the index set of the unavailable messages in $x_{S_j}$. Then, $x_{I_j}=\{x_i:i\in I_j\}$ denotes the set of requests of $R_j$. Each receiver $R_j$ is satisfied if it can successfully recover any message that is not present in its side information set, i.e., any message $x_d\in x_{I_j}$.

We can represent an instance of a pliable index coding problem using an undirected bipartite graph, one side representing the message indexes and the other side representing the receivers. We connect $R_j$ to the indices belonging to $I_j$, as in Figure 5.

Remark 3.

By having this freedom to choose the desired message for each user, PICOD can satisfy all users with a significant reduction in the number of transmissions compared to the index encoding problem with the same set of messages and the same sets of user side information.

Example 4.

We will consider the case described in Example 2 as a pliable index coding problem. Now, we have the bipartite graph in Figure 5 describing the problem. Note, for example, that client 1 demands any of the messages indexed in $I_1=\{1,2\}$ and knows the indexed messages in $S_1=\{3,4\}$; client 3 will be satisfied to receive any of the messages $x_2,x_3$ or $x_4$, since it only knows $x_1$.

Pliable Index Coding via Colorings of Hypergraphs

In [21], a graph coloring approach was presented for pliable index coding. The authors have shown the existence of a coding scheme that has length $O\left({log}^2\Gamma \right)$, where $\mathrm{\Gamma }$ refers to a hypergraph parameter that captures the maximum number of intersections between edges of the PICOD hypergraph.

An instance of the pliable index encoding problem is described by $(m,n,\mathcal{I})-$PICOD, onde $\mathcal{I}=\{I_j;j\in \left[m\right]\}$, and can be conveniently represented by a hypergraph.

Definition 9.

The hypergraph $\mathcal{H}(\mathcal{V},{\mathcal{E}}_{\mathcal{H}})$, with $\mathcal{V}=\left[n\right]$ vertices and ${\mathcal{E}}_{\mathcal{H}}=\{e_j=\left(I_j\right);j\in \left[m\right]\}$ hyperedges, completely describes the $(m,n,\mathcal{I})-$PICOD. The hyperedge $e_j=\left(I_j\right)$ represents the set of requests for $R_j$ (i.e., ${\mathcal{E}}_{\mathcal{H}}=\mathcal{I}$).

The problem illustrated in Example 5 can be represented by a hypergraph, as can be seen in Figure 6.

Let $\mathcal{H}=(\mathcal{V},{\mathcal{E}}_{\mathcal{H}})$ be a hypergraph and $C:\mathcal{V}\to \left[L\right]$ be a coloring of $\mathcal{V}$, where L is a positive integer. We say that C is a conflict-free coloring for the hyperdges, if each ${\mathcal{E}}_{\mathcal{H}}$ of $\mathcal{H}$ has at least one vertex with unique color. The smallest number of colors required for such a coloring is called the conflict-free chromatic number of $\mathcal{H}$, denoted by ${\chi }_{CF}\left(\mathcal{H}\right)$. This parameter was first introduced by Even et al. [22].

Remark 4.

In [21], pliable index coding was given a graph coloring approach. The authors have shown the existence of a coding scheme that has length $O\left({log}^2\Gamma \right)$, where Γ refers to a hypergraph parameter that captures the maximum number of “incidences” of other hyperedges in any given hyperedge. This result improves the best known achievable results, in some parameter regimes.

Definition 10.

A pliable index code (PIC) consists of a collection of an encoding function on the server that encodes the n messages to an $\ell -$length codeword,

$${\displaystyle \varphi :{\mathcal{X}}^n⟶{\mathcal{X}}^{\ell },}$$

and decoding functions ${\displaystyle {\psi }_j:{\mathcal{X}}^{\ell }\times {\mathcal{X}}^{\mid S_j\mid }⟶\mathcal{X},}$ satisfying ${\psi }_j(\varphi \left(x\right),x_{S_j})=x_d,$ for some $d\in I_j$.

The quantity $\ell -$ is called the length of the pliable index code. We are interested in designing pliable index codes that have small $\ell -$.

We will assume that $\mathcal{X}={\mathbb{F}}^k$ for some finite field $\mathbb{F}$ and integer $k\ge 1$. If $k>1$, we refer to this code as a $k-$vector PIC, while the $k=1$ case is also called a scalar PIC. We will concentrate on the linear PICs. In this case, the coding function $\varphi$ is represented by a matrix $\ell \times mk$ (denoted by G) such that $\varphi \left(x_i:i\in \left[n\right]\right)=G{x}^T$, where $x=(x_{11},\dots ,x_{1k},\dots ,x_{m1},\dots ,x_{mk}).$ The smallest ℓ for which there is a linear $k-$vector PIC for an instance of the pliable index coding problem given by the hypergraph $\mathcal{H}$ will be denoted by ${\ell }_k^{\ast }\left(\mathcal{H}\right)$.

Definition 11.

Let $C:\mathcal{V}\to \left[L\right]$ be a conflict-free coloring of the hypergraph $\mathcal{H}$ that represents a PICOD. The indicator matrix associated with this coloring $G_C$, $L\times n$, is given by

$$G_c(c,i)=\left\{\begin{array}{cc}1,\hfill & ifthevertexireceivedthecolorc;\hfill \\ 0,\hfill & otherwise.\hfill \end{array}\right.$$

Teorema 1

([21]). The indicator matrix $G_c$ generates the pliable index code for the problem described by the hypergraph $\mathcal{H}$.

Example 5.

Consider the same PICOD represented in Figure 6. The coloring shown in Figure 7 is a conflict-free coloring with two colors. Then, the matrix $G_c=\left[\begin{array}{cccc}1& 0& 0& 1\\ 0& 1& 1& 0\end{array}\right].$

From the messages $x_1\oplus x_4$ and $x_2\oplus x_3$, all receivers can successfully recover at least one message from their request set.

Using the same parameters as in Example 2, we see that the length of the index code for this instance is $\ell =3$, while, for the PICOD case, ${\ell }_k^{\ast }\left(\mathcal{H}\right)=2$.

2.5. Index Coding via MDS Codes

The index coding model defined in Section 2.3, via graph theory, is only one of many approaches used to describe and solve an index encoding problem. One of the most interesting index coding schemes using codes has the maximum distance separable (MDS) property, which consists of transmitting $\kappa \left(\mathcal{G}\right)=n-mindeg\left(\mathcal{G}\right)$, the parity symbols of a systematic MDS code with parameters $(n+\kappa ,n)$, where $mindeg\left(\mathcal{G}\right)$ represents the minimum amount of side information available at each receiver, i.e., for a general index encoding problem with side information graph $\mathcal{G}$,

$${\displaystyle \mathrm{mindeg}\left(\mathcal{G}\right)\triangleq {\min }_{i\in \left[n\right]}\left|\{j;(i,j)\in \mathcal{E}\left(\mathcal{G}\right)\}\right|={\min }_{i\in \left[n\right]}\left|S_i\right|.}$$

Then, every receiver has n code symbols (including its side information) and, by the MDS property, it can successfully recover its desired message.

Proposition 1

([1]). Consider an index coding problem with n messages and n receivers represented by the side information graph $\mathcal{G}$. Let $S_i$, the side information set of the receiver $R_i,i\in \left[n\right]$, and then

$${\displaystyle {\mathrm{minrk}}_q\left(\mathcal{G}\right)\le \kappa \left(\mathcal{G}\right)=n-\mathrm{mindeg}\left(\mathcal{G}\right)=n-{\min }_{i\in \left[n\right]}\left|S_i\right|.}$$

Corollary 1.

If $\mathcal{G}$ is a complete graph, then $mindeg\left(\mathcal{G}\right)=n-1$ and the transmission of the parity symbol $x_1+\cdots +x_n$ of an $(n+1,n)$ MDS code over ${\mathbb{F}}_2$ achieves minrk${}_q\left(\mathcal{G}\right)=1$.

3. Results

The tree construction method proposed in [12] can be interpreted as a network coding problem with multiple sources and multiple users. In the proposed model, both encoding and decoding are performed by polynomial operations, without the need for side information; however, if they exist, they may allow multiple interpretations at the receivers, based on the side information available at each receiver. Figure 8 illustrates this system model.

Given the connection between network and index coding problems, established in [4], we can also interpret the coding with nested cyclic codes, at the stage where the packets are XOR-ed together, as a case of MDS index coding according to Corollary 1, in the particular case where each receiver is unaware of the message it is requesting, which may be a rare occurrence. However, it is possible to take advantage of the method’s distinguishing feature—the possibility of multiple interpretations at the receivers—and, by imposing some extra conditions, design an index code model that has greater flexibility over the side information sets.

In the next subsections, we present some results and algorithm implementations, and in Section 4, we present in detail the proposed index encoding with multiple interpretations.

3.1. Index Coding from Reed–Solomon Codes

We establish a connection between index coding and error-correcting codes based on the tree construction method of nested cyclic codes proposed in [12]. We implement a few algorithms to perform tree construction using the Matlab language, which allows us to work over finite bodies in a practical and efficient way and helps to solve some implementation problems encountered later in [12]. We prove that for cyclic codes, there will not always be an increase in error correction capability between the levels of the tree, as suggested in [12]. This is why we have initially limited this study to Reed–Solomon codes, because they are MDS codes, which guarantees an increase in Hamming distance at each level, meaning that, under certain conditions, the knowledge of side information will be interpreted as an increase in the decoder’s ability to correct errors.

A Tree Construction with Nested Cyclic Codes

A nested code is characterized by a global code where each element is given by a sum of codewords, each belonging to a different subcode. That is,

$$c=i_1{G}_1\oplus i_2{G}_2\oplus \cdots \oplus i_N{G}_N,$$

where ⊕ represents an XOR operation. For an information vector $i_{\ell },1\le \ell \le N$, the codeword $i_{\ell }{G}_{\ell }$ belongs to a subcode ${\mathcal{C}}_{\ell }$ of code $\mathcal{C}$ and $c\in \mathcal{C}$.

Nested cyclic codes, whose subcodes are generated by generator polynomials, were originally proposed by Heegard [23], and were originally called partitioned linear block codes. They can be defined as follows:

Definition 12.

Let $\mathcal{C}=\{C\left(x\right)\in F_q\left[x\right];g\left(x\right)|C\left(x\right)\}$ be a t-error-correcting cyclic code having $g\left(x\right)$ as the generator polynomial. Note that $\mathcal{C}=\langle g\left(x\right)\rangle$ is an ideal of the ring $R_n={\mathbb{F}}_q\left[x\right]/(x^n-1)$, but is also a vector subspace of ${\mathbb{F}}_q^n$, such that

$$C\left(x\right)=p_1\left(x\right)g_1\left(x\right)+p_2\left(x\right)g_2\left(x\right)+\cdots +p_N\left(x\right)g_N\left(x\right),$$

where $C_{\ell }\left(x\right)=p_{\ell }\left(x\right)g_{\ell }\left(x\right)$, $1\le \ell \le N$ is an encoded packet belonging to the $t_{\ell }$-error-correcting subcode

$${\mathcal{C}}_{\ell }=\{C_{\ell }\left(x\right)\in F_q\left[x\right];g_{\ell }\left(x\right)|C_{\ell }\left(x\right)\},$$

generated by $g_{\ell }\left(x\right)$ and satisfying the following conditions:

1.

$g_{\ell }\left(x\right)|g_{\ell +1}\left(x\right)$;

2.

$deg\left[C_{\ell }\left(x\right)\right]<deg\left[g_{\ell +1}\left(x\right)\right]$.

The tree-based algebraic construction of nested cyclic codes, proposed in [12], aims to

1.

Encode, independently, different data packets, providing protection against channel errors;

2.

Encode different data packets producing codewords that are added, resulting in the packet $C_0$;

3.

Correct the errors on $C_0$ and, finally, recover the data in the receiver by polynomial operations.

Consider a tree in which the root node is associated with the vector subspace of an encompassing error correcting code. Thus, the root node is defined as the code ${\mathcal{C}}_{i0}$, such that

$${\mathcal{C}}_{i0}=\langle g_{i0}\left(x\right)\rangle =\{C_{i0}\left(x\right)\in F_q\left[x\right];g_{i0}\left(x\right)|C_{i0}\left(x\right)\}.$$

This subspace corresponds to a $t_0$-error-correcting cyclic code ${\mathcal{C}}_{i0}(n,k_{i0})$, generated by the polynomial $g_{i0}\left(x\right)$.

Definition 13.

A tree of nested cyclic codes is a finite tree such that

1.

Each inner node (including the root node) can be subdivided into another inner node and a terminal node;

2.

The jth th inner node is associated with a linear subspace ${\mathcal{C}}_{ij}\subset F_q^n$ of dimension $k_{ij}$, and can be subdivided into the subspaces

$${\mathcal{C}}_{ij}={\mathcal{C}}_{i(j+1)}+{\mathcal{C}}_{t(j+1)}\mathit{com}{\mathcal{C}}_{i(j+1)}\cap {\mathcal{C}}_{t(j+1)}=\left\{0\right\}\mathrm{e}{k}_{ij}=k_{i(j+1)}+k_{t(j+1)}$$

3.

The subspace ${\mathcal{C}}_{ij}$, associated with the jth inner node, must be a cyclic linear block code generated by $g_{ij}\left(x\right)$;

4.

If ${\mathcal{C}}_{ij}=\langle g_{ij}\left(x\right)\rangle$ e ${\mathcal{C}}_{i(j+1)}=\langle g_{i(j+1)}\left(x\right)\rangle$, then $g_{ij}\left(x\right)|g_{i(j+1)}\left(x\right)$; furthermore, $g_{ij}\left(x\right)|x^n-1$ for any $g_{ij}\left(x\right)$;

5.

To conclude, the last inner node will have no ramifications.

Remark 5.

Figure 9 illustrates the model described above.

Let $p_j\left(x\right)$ be the data packet associated with the terminal node, for $1\le j\le T$. The encoding is given by

$$C_j\left(x\right)=p_j\left(x\right)g_{i(j-1)}\left(x\right).$$

Then, the encoded packets are summed up and the resulting codeword is sent out by the transmitter

$$C_0\left(x\right)=C_1\left(x\right)+C_2\left(x\right)+\cdots +C_T\left(x\right).$$

After the error correction phase, the jth packet $p_j\left(x\right)$ is decoded by the operations:

$${\displaystyle p_j\left(x\right)=\left\{\begin{array}{cc}{\displaystyle [C_0\left(x\right)mod{g}_{ij}\left(x\right)]/g_{i(j-1)}\left(x\right)}\hfill & \mathrm{if}1\le j\le T,\hfill \\ {\displaystyle C_0\left(x\right)/g_{i(T-1)}\left(x\right)}\hfill & \mathrm{if}j=T.\hfill \end{array}\right.}$$

(1)

The information will be contained in the remainder of the division of $C_0\left(x\right)$ by $g_{ij}\left(x\right)$, since the modulo operation eliminates the influence of all messages related to polynomials of degree equal to or greater than the degree of $g_{ij}$. Thus, the quotient of the final division operation provides the desired information, since all other messages have degree less than the degree of the divisor polynomial. Therefore, in the case of the last package, only the division operation is required. We suggest consulting [12] for more details on the encoding process using the tree construction method.

3.2. Tree Construction: Algorithm and Considerations

We describe a few algorithms in Matlab and considerations for fitting to the model of tree construction, which can be found at [20], allowing us to perform the calculations on finite fields by making the appropriate transformations from integer representation to powers of $\alpha$. Below, we exemplify the main idea of the algorithm.

Example 6.

For $T=3$ let ${\mathcal{C}}_{i0}(7,5)$ be a Reed–Solomon code in $GF\left(8\right)$ and $k_{t1}=k_{t2}=2$ the dimensions of subspaces ${\mathcal{C}}_{t1},{\mathcal{C}}_{t2}$, respectively. They are associated with the terminal nodes of the tree; the last node of the tree, which is an inner node without ramification, is associated with ${\mathcal{C}}_{i2}$ of dimension $k_{i2}=1$.

The packets $p_1\left(x\right)=x+{\alpha }^2,p_2\left(x\right)={\alpha }^{3}x+\alpha$, both associated with the the terminal nodes, have length 2; $p_3\left(x\right)={\alpha }^5$ has length equal to 1 and is associated with the last node. Let $\alpha$ be the primitive element of $GF\left(8\right)$, and the generator polynomials are

• $deg\left(g_{i0}\left(x\right)\right)=n-k_{i0}=2$${\displaystyle \Rightarrow g_{i0}\left(x\right)=\prod _{j=1}^2(x-{\alpha }^j)=x^2+{\alpha }^{4}x+{\alpha }^3;}$
• $deg\left(g_{i1}\left(x\right)\right)=n-k_{i1}=4$${\displaystyle \Rightarrow g_{i1}\left(x\right)=\prod _{j=1}^4(x-{\alpha }^j)=x^4+{\alpha }^3{x}^3+x^2+\alpha x+{\alpha }^3;}$
• $deg\left(g_{i2}\left(x\right)\right)=n-k_{i2}=6$${\displaystyle \Rightarrow g_{i2}\left(x\right)=\prod _{j=1}^6(x-{\alpha }^j)=x^6+x^5+x^4+x^3+x^2+x+1.}$

Then, the encoded packets are

• $\begin{array}{ccc}{C}_1\left(x\right)& =& p_1\left(x\right)g_{i0}\left(x\right)\hfill \\ & =& x^3+\alpha x^2+{\alpha }^{4}x+{\alpha }^5;\hfill \end{array}$
• $\begin{array}{ccc}{C}_2\left(x\right)& =& p_2\left(x\right)g_{i1}\left(x\right)\hfill \\ & =& {\alpha }^3{x}^5+{\alpha }^5{x}^4+{\alpha }^6{x}^3+{\alpha }^2{x}^2+x+{\alpha }^4;\hfill \end{array}$
• $\begin{array}{ccc}{C}_3\left(x\right)& =& p_3\left(x\right)g_{i2}\left(x\right)\hfill \\ & =& {\alpha }^5{x}^6+{\alpha }^5{x}^5+{\alpha }^5{x}^4+{\alpha }^5{x}^3+{\alpha }^5{x}^2+{\alpha }^{5}x+{\alpha }^5.\hfill \end{array}$

The transmitted codeword $C_0\left(x\right)$ is given by

• $\begin{array}{ccc}{C}_0\left(x\right)& =& C_1\left(x\right)+C_2\left(x\right)+C_3\left(x\right)\hfill \\ & =& {\alpha }^5{x}^6+{\alpha }^2{x}^5+0x^4+{\alpha }^3{x}^3+1x^2+0x+{\alpha }^4.\hfill \end{array}$

Remark 6.

Each terminal node is a shortened version of the code associated with the inner node from which the terminal node emanates. It is implicit that the codewords of shortened codes are prefixed with zeros to achieve length n and, therefore, that these codes are not cyclic.

3.2.1. Decoding—Error Correction

Considering tree construction based on Reed–Solomon codes and assuming that the receiver has side information available, when will there be an increase in error correction capability?

Proposition 2.

Due to the nesting structure, the variable error correctability characteristic can only be observed if there is a sequential removal of the packets associated with the nodes from the root to the top of the tree.

Proof. 

Supposing that $C_{\ell }\left(x\right),1\le \ell \le T$ is the first coded packet known at the receiver, then

$$\begin{array}{cc}\hfill C_0\left(x\right)& =p_1\left(x\right)g_{i0}\left(x\right)+\cdots +p_{(\ell -1)}\left(x\right)g_{i(\ell -2)}\left(x\right)+p_{(\ell +1)}\left(x\right)g_{i\ell }\left(x\right)+\cdots +p_T\left(x\right)g_{i(T-1)}\left(x\right)\hfill \\ \hfill & =[p_1\left(x\right)+\cdots +p_{(\ell -1)}\left(x\right)q_{(\ell -1)}\left(x\right)+p_{(\ell +1)}\left(x\right)q_{(\ell +1)}\left(x\right)+\cdots +p_T\left(x\right)q_T\left(x\right)]g_{i0}\left(x\right),\hfill \end{array}$$

therefore, $C_0\left(x\right)\in {\mathcal{C}}_{i0}(n,k_{io})$, whose error correction capability is $t_0$. Note that even though the receiver knows about other packages $C_j\left(x\right),\ell <j\le T$, the result does not change. On the other hand, if all packages $C_j\left(x\right);1\le j<\ell$ are known to the receiver, we can write

$$\begin{array}{cc}\hfill C_0\left(x\right)& =p_{(\ell +1)}\left(x\right)g_{i\ell }\left(x\right)+\cdots +p_T\left(x\right)g_{i(T-1)}\left(x\right)\hfill \\ \hfill & =[p_{(\ell +1)}\left(x\right){\overline{q}}_{(\ell +1)}\left(x\right)+\cdots +p_T\left(x\right){\overline{q}}_T\left(x\right)]g_{i\ell }\left(x\right),\hfill \end{array}$$

thus, $C_0\left(x\right)\in {\mathcal{C}}_{i\ell }(n,k_{i\ell })$, whose error correction capability is $t_{\ell }⩾t_0$, and equality occurs only when

$$d_{min}\left(C_{\ell }\right)-d_{min}\left(C_0\right)<2.$$

□

Example 7.

Consider the same tree as in Example 6.

• If all packages are unknown ⇒ the decoding is performed by ${\mathcal{C}}_{i0}(7,5)$∴$t_0=1$;
• If $C_1\left(x\right)$ is known ⇒ the decoding is performed by ${\mathcal{C}}_{i1}(7,3)$∴$t_1=2$;
• If $C_2\left(x\right)$ is known $C_1\left(x\right)\Rightarrow$ the decoding is performed by ${\mathcal{C}}_{i2}(7,1)$∴$t_2=3$.

However, if $C_2\left(x\right)$ is known but $C_1\left(x\right)$ is not, then the resulting codeword still belongs to $C_0\left(x\right)\in {\mathcal{C}}_{i0}(7,5)$, and there is no improvement in error correction capability, since

$$\begin{array}{cc}\hfill C_0\left(x\right)& =p_1\left(x\right)g_{i0}\left(x\right)+p_3\left(x\right)g_{i0}\left(x\right)\overline{q}\left(x\right)\hfill \\ \hfill & =[p_1\left(x\right)+p_3\left(x\right)\overline{q}\left(x\right)]g_{i0}\left(x\right).\hfill \end{array}$$

Another advantage of Reed–Solomon codes is that they are easily decoded using an algebraic method known as syndrome decoding.

Syndrome Decoding

Syndrome decoding is an algebraic method based on the Berlekamp–Massey algorithm, which became a prototype for the decoding of many other linear codes.

If the coded package $C_1\left(x\right)$ is known and an error $e\left(x\right)$ occurs, then the message received will be

$$\begin{array}{cc}\hfill r\left(x\right)& =C_0\left(x\right)+C_1\left(x\right)+e\left(x\right)\hfill \end{array}$$

Suppose that the error is given by $e\left(x\right)=0x^6+0x^5+{\alpha }^2{x}^4+{\alpha }^5{x}^3+0x^2+0x+0$, and then

$$\begin{array}{cc}\hfill r\left(x\right)& ={\alpha }^5{x}^6+{\alpha }^2{x}^5+{\alpha }^2{x}^4+{\alpha }^6{x}^3+{\alpha }^3{x}^2+{\alpha }^{4}x+1.\hfill \end{array}$$

Remark 7.

Notice that we need to find the error locations and their values, which is the main difference with binary codes, since, for binary codes, it is enough to determine the error locations.

The decoding process can be divided into three stages.

1.

Syndrome calculation

The syndrome calculation stage consists of checking the roots of the generating polynomial as inputs of $r\left(x\right)$. If the result is null, the sequence belongs to the set of codewords and, therefore, there are no errors. Any nonzero value indicates the presence of an error.

If the encoded packet $C_1\left(x\right)$ is known, then the error correction algorithm is executed by ${\mathcal{C}}_{i1}$, which is a $RS(7,3)$ code, generated by $g_{i1}\left(x\right)=(x-\alpha )(x-{\alpha }^2)(x-{\alpha }^3)(x-{\alpha }^4)$. Then,

$$\begin{array}{cc}\hfill r\left(x\right)& =m\left(x\right)g_{i1}\left(x\right)+e\left(x\right),\hfill \end{array}$$

Therefore, evaluating the roots of $g\left(x\right)$ at $r\left(x\right)$, the result will only be null when there are no errors in the transmission.

$$\therefore S_i=r\left(x\right){|}_{x={\alpha }^i}=e\left({\alpha }^i\right),\forall i=1,\dots ,n-k=2t.$$

$$\begin{array}{ccc}{S}_1=r\left(\alpha \right)={\alpha }^5;\hfill & \hspace{1em}& S_3=r\left({\alpha }^3\right)=0;\hfill \\ S_2=r\left({\alpha }^2\right)={\alpha }^6;\hfill & \hspace{1em}& S_4=r\left({\alpha }^4\right)={\alpha }^6.\hfill \end{array}$$

2.

Error Localization

Let $\mu$ be the number of errors $0\le \mu \le t$, which occur at locations ${\ell }_1,\cdots ,{\ell }_{\mu }$, and the error polynomial can be written as

$$e\left(x\right)=e_{{\ell }_1}{x}^{{\ell }_1}+\cdots +e_{{\ell }_{\mu }}{x}^{{\ell }_{\mu }}.$$

To correct $r\left(x\right)$, we must find the values and locations of the errors, which are denoted, respectively, by $e_{{\ell }_1},\dots ,e_{{\ell }_{\mu }}$ and $x^{{\ell }_1},\dots ,x^{{\ell }_{\mu }}$. Substituting ${\alpha }^j,1\le j\le 2t$, into the error polynomial $e\left(x\right)$, we obtain

$$\left\{\begin{array}{c}\begin{array}{ccccc}{S}_1& =& e\left(\alpha \right)& =& e_{{\ell }_1}{\alpha }^{{\ell }_1}+e_{{\ell }_2}{\alpha }^{{\ell }_2}+\cdots +e_{{\ell }_{\mu }}{\alpha }^{{\ell }_{\mu }}\hfill \\ S_2& =& e\left({\alpha }^2\right)& =& e_{{\ell }_1}{\left({\alpha }^{{\ell }_1}\right)}^2+e_{{\ell }_2}{\left({\alpha }^{{\ell }_2}\right)}^2+\cdots +e_{{\ell }_{\mu }}{\left({\alpha }^{{\ell }_{\mu }}\right)}^2\hfill \\ & ⋮& \\ S_{2t}& =& e\left({\alpha }^{2t}\right)& =& e_{{\ell }_1}{\left({\alpha }^{{\ell }_1}\right)}^{2t}+e_{{\ell }_2}{\left({\alpha }^{{\ell }_2}\right)}^{2t}+\cdots +e_{{\ell }_{\mu }}{\left({\alpha }^{{\ell }_{\mu }}\right)}^{2t}\hfill \end{array}\hfill \end{array}\right..$$

Obtain $X_i={\alpha }^{{\ell }_i}$ and $Y_i=e_{{\ell }_i}$ for $1\le i\le \mu$, where $X_i$ and $Y_i$ will represent, respectively, the locations and values of the errors. Note that we will have $2t$ equations and $2t$ unknowns, t being error values and t being locations.

$$\left\{\begin{array}{c}\begin{array}{ccc}{S}_1& =& Y_1{X}_1+Y_2{X}_2+\cdots +Y_{\mu }{X}_{\mu }\hfill \\ S_2& =& Y_1{X_1}^2+Y_2{X_2}^2+\cdots +Y_{\mu }{X}_{\mu }^2\hfill \\ & ⋮& \\ S_{2t}& =& Y_1{X_1}^{2t}+Y_2{X_2}^{2t}+\cdots +Y_{\mu }{X}_{\mu }^{2t}\hfill \end{array}\hfill \end{array}\right..$$

It can be shown that this nonlinear system has a unique solution if $0\le \mu \le t$ [15]. The techniques that solve this system of equations include defining the error locator polynomial (ELP) $\sigma \left(z\right)$ [24].

Definition 14.

Define the error locator polynomial $sigma\left(z\right)$, as

$$\begin{array}{ccc}\hfill \sigma \left(z\right)& =& (1-X_{1}z)(1-X_{2}z)\cdots (1-X_{\mu }z)\hfill \\ & =& {\sigma }_{\mu }{z}^{\mu }+\cdots +{\sigma }_2{z}^2+{\sigma }_{1}z+1.\hfill \end{array}$$

The inverse of the square root of $\sigma \left(z\right)$, $1/X_1,\dots ,1/X_{\mu }$, indicates the locations of errors.

To find error locations $X_i,1\le i\le \mu$, note that ${\sigma }_1,{\sigma }_2,\dots ,{\sigma }_{\mu }$ and calculate the zeros of $\sigma \left(z\right)$; to find them, we use a syndrome matrix, as we see below:

$$\begin{array}{cc}\hfill \left[\begin{array}{cccc}{S}_1& S_2& \cdots & S_{\mu }\\ S_2& S_3& \cdots & S_{\mu +1}\\ ⋮& ⋮& \ddots & ⋮\\ S_{\mu }& S_{\mu +1}& \cdots & S_{2\mu -1}\end{array}\right]\left[\begin{array}{c}{\sigma }_{\mu }\\ {\sigma }_{\mu -1}\\ ⋮\\ {\sigma }_1\end{array}\right]& =\left[\begin{array}{c}-S_{\mu +1}\\ -S_{\mu +2}\\ ⋮\\ -S_{2\mu }\end{array}\right]\hfill \end{array}$$

Returning to Code RS(7,3), where the error correction capability is $t=2$, we must find ${\sigma }_1$ e ${\sigma }_2$:

$$\begin{array}{cc}\hfill \left[\begin{array}{cc}{S}_1& S_2\\ S_2& S_3\end{array}\right]\left[\begin{array}{c}{\sigma }_2\\ {\sigma }_1\end{array}\right]& =\left[\begin{array}{c}{S}_3\\ S_4\end{array}\right]\hfill \\ \hfill \left[\begin{array}{cc}{\alpha }^5& {\alpha }^6\\ {\alpha }^5& 0\end{array}\right]\left[\begin{array}{c}{\sigma }_2\\ {\sigma }_1\end{array}\right]& =\left[\begin{array}{c}0\\ {\alpha }^6\end{array}\right]\Rightarrow {\sigma }_2=1e{\sigma }_1={\alpha }^6\hfill \end{array}$$

Thus, $\sigma \left(z\right)=z^2+{\alpha }^{6}z+1$ with roots ${\alpha }^3$ and ${\alpha }^4$, so there is an error at the locations ${\alpha }^{-3}={\alpha }^4$ and ${\alpha }^{-4}={\alpha }^3$. Then,

$$e\left(x\right)=e_3{x}^3+e_4{x}^4.$$

3.

Determining the error values

Calculating $e\left(x\right)=e_3{x}^3+e_4{x}^4$ at the points $\alpha$ and ${\alpha }^2$, we can use the syndromes already obtained, $S_1$ and $S_2$, to determine the values of the errors, solving the following system:

$$\left\{\begin{array}{c}\begin{array}{ccccc}{S}_1& =& e\left(\alpha \right)& =& e_3{\alpha }^3+e_4{\alpha }^4\hfill \\ S_2& =& e\left({\alpha }^2\right)& =& e_3{\alpha }^6+e_4{\alpha }^8\hfill \end{array}\hfill \end{array}\right.$$

Therefore, the error polynomial is given by $e\left(x\right)={\alpha }^5{x}^3+{\alpha }^2{x}^4.$ Now, correcting the received word $r\left(x\right)$, we have

$$\begin{array}{cc}\hfill C_0\left(x\right)& =r\left(x\right)+c_1\left(x\right)+e\left(x\right)\hfill \\ \hfill & ={\alpha }^5{x}^6+{\alpha }^2{x}^5+0x^4+{\alpha }^3{x}^3+1x^2+0x+{\alpha }^4.\hfill \end{array}$$

3.2.2. Decoding—Data Recovery

Example 8.

For the cases in the previous examples, where $T=3$, the original data can be recovered as follows:

$$\begin{array}{cc}\hfill •\hspace{1em}{p}_1\left(x\right)& ={\displaystyle \frac{C_0\left(x\right)mod{g}_{i1}\left(x\right)}{g_{i0}\left(x\right)}}={\displaystyle \frac{p_1{g}_{i0}mod{g}_{i1}}{g_{i0}\left(x\right)}}={\displaystyle \frac{p_1\left(x\right)g_{i0}\left(x\right)}{g_{i0}\left(x\right)}};\hfill \\ \hfill •\hspace{1em}{p}_2\left(x\right)& ={\displaystyle \frac{C_0\left(x\right)mod{g}_{i2}\left(x\right)}{g_{i1}\left(x\right)}}={\displaystyle \frac{p_1{g}_{i0}mod{g}_{i2}+p_2{g}_{i1}mod{g}_{i2}}{g_{i1}\left(x\right)}};\hfill \\ \hfill •\hspace{1em}{p}_3\left(x\right)& ={\displaystyle \frac{C_0\left(x\right)}{g_{i2}\left(x\right)}}={\displaystyle \frac{p_1\left(x\right)g_{i0}\left(x\right)}{g_{i2}\left(x\right)}}+{\displaystyle \frac{p_2\left(x\right)g_{i1}\left(x\right)}{g_{i2}\left(x\right)}}+{\displaystyle \frac{p_3\left(x\right)g_{i2}\left(x\right)}{g_{i2}\left(x\right)}};\hfill \end{array}$$

In summary, the module operation removes the branches above the node of interest and the division operation removes the branches below. Therefore, no side information is needed at the receiver in order to recover the data packets.

Will There Always Be an Increase in Error Correction Capability?

We analyze two cases of tree construction of nested cyclic codes, with the same parameters at each level. In one of them, we observe no increase in the error correction capability from the second to last internal node of the tree. This is due to the variety of possibilities of generating polynomials for a cyclic code of parameters $(n,k)$. As a result, we demonstrate in Proposition 3 that, for Reed–Solomon codes, this feature of increasing capacity will be guaranteed provided that: $k_{ij}-k_{i(j+1)}\ge 2,\forall j=0,\dots ,T-1.$

Example 9.

Let ${\mathcal{C}}_{i0}(15,10)$ be a cyclic code in $GF\left(2\right)$ and $k_{t1}=4,k_{t2}=2$ be the dimensions of the subspaces ${\mathcal{C}}_{t1},{\mathcal{C}}_{t2}$, respectively. The last node is associated with ${\mathcal{C}}_{i2}$ with dimension $k_{i2}=4$. The construction is depicted in Figure 10.

We consider the factorization:

$$x^{15}-1=(1+x)(1+x^3+x^4)(1+x+x^2+x^3+x^4)(1+x+x^2)(1+x+x^4)$$

Case 1.

•	$g_{i0}\left(x\right)=(1+x)(1+x^3+x^4)\hspace{1em}$	⇒	$t_0=1;$
•	$g_{i1}\left(x\right)=g_{i0}\left(x\right)(1+x+x^2+x^3+x^4)\hspace{1em}$	⇒	$t_1=2;$
•	$g_{i2}\left(x\right)=g_{i1}\left(x\right)(1+x+x^2)\hspace{1em}$	⇒	$t_2=3.$

Case 2.

•	$g_{i0}\left(x\right)=(1+x)(1+x+x^4)\hspace{1em}$	$\Rightarrow$	$t_0=1;$
•	$g_{i1}\left(x\right)=g_{i0}\left(x\right)(1+x^3+x^4)\hspace{1em}$	$\Rightarrow$	$t_1=2;$
•	$g_{i2}\left(x\right)=g_{i1}\left(x\right)(1+x+x^2)\hspace{1em}$	$\Rightarrow$	$t_2=2.$

Remark 8.

We have provided an m-file algorithm at [20], which can be run through Matlab and performs the operations described in Examples 8 and 9.

Proposition 3.

Given a $(n,k)$ Reed–Solomon code, which has minimum distance $d=n-k+1$, one can guarantee an increase in error correction capability at each level of the tree provided that $k_{ij}-k_{i(j+1)}\ge 2,\forall j=0,\dots ,T-1$.

Proof. 

We must prove that $t_{i(j+1)}\ge t_{ij}+1,\forall j=0,\dots ,T-1$. For simplicity but without loss of generality, set $j=0$. If $k_{i0}-k_{i1}\ge 2$, then we can write:

$$\begin{array}{cc}\hfill (-d_{i0}+n+1)+d_{i1}-n-1& \ge 2\hfill \\ \hfill d_{i1}-1& \ge d_{i0}-1+2\hfill \\ \hfill \left[{\displaystyle \frac{d_{i1}-1}{2}}\right]& \ge \left[{\displaystyle \frac{d_{i0}-1}{2}}\right]+1\hfill \\ \hfill t_{i1}& \ge t_{i0}+1.\hfill \end{array}$$

This completes the proof. □

The verification that, for cyclic codes, there will not always be an increase in the error correction capacity between the levels of the tree, as considered in [12], leads us to search for answers on how to properly choose the generating polynomials for a code of parameters $(n,k)$ and its subcodes, in order to guarantee subcodes with larger Hamming distance, with the purpose of observing an increase in the error correction capacity between the levels of the tree. An approach to constructing chains of some linear block codes while keeping the minimum distances (of the generated subcodes) as large as possible is presented in [25] and may be the solution to this problem.

3.3. An Example with a BCH Code

According to Luo and Vinck [25], to construct a chain of BCH subcodes with the characteristic of maintaining the minimum distance as large as possible, the task becomes more difficult because their subcodes may not be BCH and cyclic codes, and therefore the minimum distance of these subcodes might not be found easily. However, for primitive BCH codes, the minimum distance coincides with the weight of the generator polynomial, which makes it feasible to use it for the construction of the nested subcode chain that we seek. For non-primitive BCH codes, this statement is not always valid. For an extensive description of the minimum distance for BCH codes, we recommend consulting [26].

In

Table 1. Parameters for values of $m\le 6$.

		$\mathit{m}=3$		$\mathit{m}=4$				$\mathit{m}=5$						$\mathit{m}=6$
n		7		15				31						63
k		4		11	7	5		26	21	16	11	6		57	51	45	39	36	30	24	18	16	10	7
t		1		1	2	3		1	2	3	5	7		1	2	3	4	5	6	7	10	11	13	15

Note that there will always be an increase in error correction capability for a fixed n and varying k.

, we present the parameters for binary primitive BCH codes of length $n=2^m-1$; it will guide the tree construction.

Example 10.

Consider the root node associated with the BCH code ${\mathcal{C}}_{i0}(15,11)$. Suppose that we want to encode the packets $p_1\left(x\right)=x^3+x^2+x$, $p_2\left(x\right)=x$ and $p_3\left(x\right)=x^4+x^2+1$ associated with nodes whose dimensions are $k_{t1}=4$, $k_{t2}=2$ and $k_{i2}=5$, respectively. The polynomials $g_{i0}\left(x\right)=x^4+x+1$, $g_{i1}\left(x\right)=x^8+x^7+x^6+x^4+1)$ and $g_{i2}\left(x\right)=x^{10}+x^8+x^5+x^4+x^2+x+1$ generate the codes associated with the internal nodes, ${\mathcal{C}}_{i0}(15,11)$, ${\mathcal{C}}_{i1}(15,7)$ e ${\mathcal{C}}_{i2}(15,5)$, respectively, as shown in Figure 11.

Encoding the packets, we have:

• $\begin{array}{ccc}{C}_1\left(x\right)& =& p_1\left(x\right)g_{i0}\left(x\right)\hfill \\ & =& x^7+x^6+x^5+x^4+x;\hfill \end{array}$
• $\begin{array}{ccc}{C}_2\left(x\right)& =& p_2\left(x\right)g_{i1}\left(x\right)\hfill \\ & =& x^9+x^8+x^7+x^5+x;\hfill \end{array}$
• $\begin{array}{ccc}{C}_3\left(x\right)& =& p_3\left(x\right)g_{i2}\left(x\right)\hfill \\ & =& {\alpha }^5{x}^6+{\alpha }^5{x}^5+{\alpha }^5{x}^4+{\alpha }^5{x}^3+{\alpha }^5{x}^2+{\alpha }^{5}x+{\alpha }^5.\hfill \end{array}$

The transmitted codeword $C_0\left(x\right)$ is given by:

$$\begin{array}{ccc}{C}_0\left(x\right)& =& C_1\left(x\right)+C_2\left(x\right)+C_3\left(x\right)\hfill \\ & =& x^{14}+x^8+x^7+x^6+x^3+x+1\hfill \end{array}$$

Alternatively, it is possible to represent the codeword in vector form:

$$C_0\left(x\right)=(1,0,0,0,0,0,1,1,1,0,0,1,0,1,1)$$

After the error correction process, which will be performed on the sum of the coded packets, taking into account the side information available at each receiver, data recovery will occur as follows:

$$\begin{array}{cc}\hfill •\hspace{1em}{p}_1\left(x\right)& ={\displaystyle \frac{(x^{14}+x^8+x^7+x^6+x^3+x+1)mod(x^8+x^7+x^6+x^4+1)}{(x^4+x+1)}};\hfill \\ \hfill •\hspace{1em}{p}_2\left(x\right)& ={\displaystyle \frac{(x^{14}+x^8+x^7+x^6+x^3+x+1)mod(x^{10}+x^8+x^5+x^4+x^2+x+1)}{(x^8+x^7+x^6+x^4+1)}};\hfill \\ \hfill •\hspace{1em}{p}_3\left(x\right)& ={\displaystyle \frac{(x^{14}+x^8+x^7+x^6+x^3+x+1)}{(x^{10}+x^8+x^5+x^4+x^2+x+1)}}.\hfill \end{array}$$

Remark 9.

We have made available at [20] an m-file Matlab algorithm that performs the tree construction operations and the data recovery for the BCH code.

4. Index Coding with Multiple Interpretations

In the problem of index coding with multiple interpretations, we assume that receivers demand all the messages from the source and that the sender is unaware of the subset of messages already known in the receivers—performing an encoding so that any side information may be used by the decoder, in order to increase its error correction capability. Otherwise, if a receiver has no side information, the decoder considers the received word to belong to the highest rate code associated with the root node of the tree.

The proposed encoding process is shown in Figure 12 and can be performed in four main steps:

1.

Encoding of the different data packets with nested cyclic codes, which consists of subdividing the vector space of a linear block code into vector subspaces, using each of them for encoding a different user;

2.

Implementation of index coding at the relay node; the basic idea is that the different data packets, encoded by polynomial multiplications with linearly independent generators, are added and then forwarded to the receivers;

3.

Multiple interpretations at the receivers that occur at the error correction stage, where each receiver can decode the received message at different rates depending on the known side information;

4.

The data recovery stage, i.e., the process of decoding $C_1\left(x\right),\dots ,C_T\left(x\right)$ through polynomial operations (1), as described in Section 3.1.

The notion of multiple interpretations was introduced in [13], indicating that the error correction capability in decoding gradually improves as the amount of side information available at the receiver increases. However, as we prove in Proposition 2, because of the nested structure of the tree, this characteristic of variable error correction capability can only be observed if there is a sequential removal of packets associated with the nodes, i.e., the side information should occur sequentially from the root to the top of the tree. However, in practice, this is not always the case. Thus, if we want to ensure that any information can be used efficiently in the decoder, it will be necessary to assume knowledge of the side information by the relay node or even the demand set, if we have a PICOD problem.

The following is a proposal for pliable index coding with multiple interpretations.

Pliable Index Coding with Multiple Interpretations

As in the pliable index coding problem [6], we will assume that the transmitter knows the demand set of each receiver and that all receivers are satisfied by receiving any message contained in their demand set. For example, if we are searching on the internet for a red flower image and we already have some previously downloaded pictures on our computer, if we find any other image that we do not have yet, we will be satisfied.

The goal of the server is to find an encoding scheme that satisfies all receivers, using as few transmissions as possible and ensuring that all side information associated with nodes located below the node where the packet to be recovered is located may be interpreted as a gain in error correction capability, even when they do not appear in such a sequence.

The idea behind this proposal is to apply conflict-free coloring to the hypergraph that represents the demands of all receivers, and instead of sending the encoded word $C_0\left(x\right)=C_1\left(x\right)+C_2\left(x\right)+\cdots +C_T\left(x\right)$, we select the packets in a way that maximizes the possibility of a gain in error correction capability, since, as mentioned above, packages will only be removed if they occur sequentially.

Example 11.

Consider an instance of an pliable index coding with multiple interpretations in Figure 13a, where the encoded packets $C_1\left(x\right)=g_{i0}\left(x\right)p_1\left(x\right),C_2\left(x\right)=g_{i1}\left(x\right)p_2\left(x\right),C_3\left(x\right)=g_{i2}\left(x\right)p_3\left(x\right)$ and $C_4\left(x\right)=g_{i3}\left(x\right)p_4\left(x\right)$ will be sent to receivers $R_1,R_2$ and $R_3$, which have demand sets $I_1=\{1,2\}$, $I_2=\left\{3\right\}$, $I_1=\{2,4\}$, respectively, as we see in Figure 13b.

Figure 14 shows conflict-free coloring with two colors and $G_c=\left[\begin{array}{cccc}1& 0& 1& 1\\ 0& 1& 0& 0\end{array}\right]$, which represents the pliable index code.

Note that if we send only the message $C_0=C_1\oplus C_3\oplus C_4$, all receivers recover one and only one message from their request set, as we can see in

Table 2. Receivers with their side information sets.

Receivers	Side Information Sets	Decodes from Transmission
$R_1$	$S_1=\{3,4\}$	$C_1\oplus C_3\oplus C_4\oplus C_3\oplus C_4=C_1$
$R_2$	$S_2=\{1,2,4\}$	$C_1\oplus C_3\oplus C_4\oplus C_1\oplus C_4=C_3$
$R_3$	$S_3=\{1,3\}$	$C_1\oplus C_3\oplus C_4\oplus C_1\oplus C_3=C_4$

Each receiver R_j is satisfied if it can successfully recover any new message that is not present in its side information set, i.e., any message x_d ∈ $x_{I_j}$, where $I_j\triangleq \left[n\right]\setminus S_j$.

.

Depending on the problem, this would be an ideal solution, since the transmitter may want each receiver to decode only one message, in which case we would have a PICOD(1); no client can receive more than one message from its request set. The case of PICOD(1) is dealt with in detail in [27], and the following example, which aptly illustrates its use, is provided.

Consider a media service provider whom we pay for movies. The provider has a set of movies and customers pay for a certain number of movies, e.g., one movie. Suppose that the service is being sold in such a way that customers will be happy to receive any movie that they have not watched yet. There is a restriction on the service provider’s side, since customers who have paid for only one movie should not receive more than one. Therefore, it can only supply one film for each client.

5. Conclusions

The verification that, for cyclic codes, there will not always be an increase in the error correction capacity between the levels of the tree leads us to search for ways to correctly choose the generating polynomials for a code and its subcodes, in order to guarantee subcodes with larger Hamming distance and an increase in error correction capability in consecutive levels of the tree. A method for the construction of chains of some linear block codes that maintains the minimum distances (of the generated subcodes) as large as possible is presented in Vinck and may be useful in addressing this issue.

Our work deals with the construction of index coding. We treat index coding as a network coding problem and we show how it is possible to construct pliable index codes with multiple interpretations by exploiting the conflict-free coloring of a hypergraph. Studying conflict-free coloring of a hypergraph in the context of the general index coding problem seems to be an interesting direction for future studies.