The Single-Uniprior Index-Coding Problem: The Single-Sender Case and The Multi-Sender Extension

Index coding studies multiterminal source-coding problems where a set of receivers are required to decode multiple (possibly different) messages from a common broadcast, and they each know some messages a priori. In this paper, at the receiver end, we consider a special setting where each receiver knows only one message a priori, and each message is known to only one receiver. At the broadcasting end, we consider a generalized setting where there could be multiple senders, and each sender knows a subset of the messages. The senders collaborate to transmit an index code. This work looks at minimizing the number of total coded bits the senders are required to transmit. When there is only one sender, we propose a pruning algorithm to find a lower bound on the optimal (i.e., the shortest) index codelength, and show that it is achievable by linear index codes. When there are two or more senders, we propose an appending technique to be used in conjunction with the pruning technique to give a lower bound on the optimal index codelength; we also derive an upper bound based on cyclic codes. While the two bounds do not match in general, for the special case where no two distinct senders know any message in common, the bounds match, giving the optimal index codelength. The results are expressed in terms of strongly connected components in directed graphs that represent the index-coding problems.


I. INTRODUCTION
We investigate a broadcast problem over noiseless channels with receiver side information, also known as index coding [1]. In the classical setup, one sender encodes a collection of messages, and broadcasts the codeword to multiple receivers. Each receiver knows some messages a priori, and is to decode a set of messages it wants from the single codeword broadcast by the sender. The aim is to find the shortest codeword that the sender needs to broadcast to ensure that all receivers can decode the messages they want. The index-coding problem remains open to date; only a small number of special cases have been solved [1]- [6].
In this paper, we consider a class of the index-coding problem, which we refer to as single-uniprior, where each receiver knows only one message a priori, but may request multiple messages, and each message is known to only one receiver. When there is only one sender, we completely solve the single-uniprior index-coding problem. We show that linear index codes are optimal for this class-although linear index codes are suboptimal in general [7], e.g., when two receivers know the same message.
Part of the material in this paper was presented at the IEEE International Symposium on Information Theory, Istanbul, Turkey, , and at the IEEE International Conference on Communications, Ottawa, Canada, June 10-15, 2012. This work was done when Fabian Lim was with Massachusetts Institute of Technology under the support of NSF grant ECCS-1128226.
Lawrence Ong is the recipient of an Australian Research Council Future Fellowship (FT140100219).
We then extend the single-uniprior problem with a single sender to multiple senders, where each sender knows a subset of the messages. We derive lower and upper bounds on the shortest index codelength, and identify cases where the bounds match. In particular, the bounds match when no two senders know any message in common.
A. Motivation of the multi-sender single-uniprior index-coding problem The single-uniprior index-coding problem formulation is motivated by satellite communications [8]- [10], where multiple clients exchange messages through a satellite, which acts as a relay. Having no direct communication links, the clients first send their messages to the satellite via an uplink channel. The satellite decodes the messages, re-encodes, and broadcasts to the clients via a downlink channel. Here, the downlink corresponds to a single-uniprior index-coding problem, where each client is to obtain messages of other clients, and it knows only its own message a priori.
When multiple satellites are used, the downlink corresponds to a multi-sender index-coding problem. In this case, different senders know different messages a priori, due to, for instance, decoding errors when getting the messages from the clients on the uplink, line-of-sight only to some clients, or limited storage of the senders. To the best of our knowledge, this is the first paper that investigates the multi-sender index-coding problem.

II. CHANNEL MODEL AND NOTATION
An instance of the multi-sender index-coding problem (including the single-sender as a special case) consists of the following: • m independent messages, denoted by an ordered 1 set M = {x 1 , x 2 , . . . , x m }.
-Each message x i has q i binary bits, denoted by is drawn from an independent and uniform distribution over {0, 1}.
• n receivers: each receiver r ∈ {1, 2, . . . , n} -knows an ordered 1 subset of the messages a priori, K r ⊂ M, and wants/requests an ordered 1 subset of the messages, W r ⊆ M. 1 The elements are ordered in increasing indices.  Fig. 1. The multi-sender multicast single-uniprior index coding: We consider distributed-like settings where each sender s is limited to know a subset Ms of the message set M. Also, we consider a multicast setup where each receiver r knows a single unique message xr a priori, and wants a subset of messages Wr ⊂ M. Each sender s broadcasts cs to all receivers noiselessly. The aim is to find the minimum aggregated codelength |c 1 | + |c 2 | + |c 3 |. Figure 1 depicts an example of a multi-sender single-uniprior index-coding instance, where K i = {x i }.
Without loss of generality, we assume that W r ∩ K r = ∅ for any r, and that S s=1 M s = M, i.e., each message is available at some sender(s).
We define a multi-sender index code for the above setup: This means each sender s encodes its known messages into an s -bit sub-codeword. The sub-codewords of all senders are given to all receivers. The total number of transmitted bits is˜ S s=1 s , which is the index codelength. We seek the optimal (i.e., the minimum) index codelength, denoted by˜ * , as well as index codes with the optimal length. If there is only one sender, S = 1, we simplify the notation by denoting the optimal index codelength as * .
The case S = 1 reduces to the single-sender index-coding problem studied in many works [1]- [7], [11]- [24]. Clearly, for the same receiver setting {W r , K r } n r=1 , a multi-sender index code for any S > 1 case will also be a code for the singlesender S = 1 case. This is because, by definition, the only sender in the single-user case, who knows all the messages, can transmit any multi-sender index code. But the converse is not true. So, techniques for the single-sender case do not straightforwardly apply to the multi-sender case.
For both the single-sender and the multi-sender indexcoding problems, we assume that each sender knows which messages (not the message content) each receiver knows, K r , and requests, W r ; and which messages each sender has, M s . This can be achieved by having the nodes to communicate (the message-availability and message-request information) prior to index coding. Under such scenarios, index coding is useful if the messages are sufficiently long such that the overhead incurred during the prior communication is negligible. 2 In some communication scenarios, side information is strategically placed at the receivers (for example, data pre-fetching or caching [25]), and the messages in the senders' storage are populated according to their geographical locations. In such cases, the senders can be informed of all message indices in K r , W r , and M s .
If we set the number of senders to one, S = 1, and the messages to be of equal length, q i = q for all i, the optimal normalized index codelength-over all index codes and all message lengths-is commonly known as the optimal broadcast rate [4]: (1) The second equality is due to the sub-additivity property of * [12].

A. Terminology
We will represent index-coding instances by graphs, and derive bounds on * by executing graph operations. We will use common graph terminology: A directed path of length L from vertex v 0 to vertex v L consists of the following (L + 1) distinct vertices (except possibly the first and last) and L arcs: A cycle is a path with the same first and last vertices. A strongly connected component (SCC) of a graph is a maximal subgraph such that for any vertex pair (i, j) in the subgraph, there is a directed path in the subgraph from i to j, and another from j to i. A trivial SCC is an SCC with only one vertex. A leaf vertex in a graph has no outgoing arcs. Similarly, a leaf non-trivial SCC is an SCC with two or more vertices, in which there is no arc from any vertex in the SCC to any vertex outside the SCC. In other words, for each vertex in the SCC, its out-neighbors are all vertices in the SCC. A vertex j is a predecessor of vertex i if and only if there is a directed path from j to i. A path on an undirected graph is similarly defined with arcs replaced by edges. A subgraph is connected if there is a path within the subgraph from any vertex to any other vertex. A tree is a connected undirected subgraph with no cycle.

III. INDEX-CODING CLASSIFICATION AND GRAPHICAL
REPRESENTATION A single-sender instance is fully described by the message lengths {q i } m i=1 and the receiver setting {W r , K r } n r=1 . For the multi-sender extension, we further require the sender setting {M s } S s=1 .
A. Classification of index-coding instances based on the receiver setting We first consider the single-sender setup, and categorize the instances as follows: 1) Information flow: We classify different types of information flow from the sender to the receivers. We say that an index-coding instance is unicast if meaning that each message can be requested by at most one receiver. In addition, we say that the instance is single-unicast if, in addition to (2), we also have that |W i | = 1 for all i, meaning each receiver requests exactly one message-but the message may consist of multiple bits. Note that any unicast instance can be recast as a singleunicast instance [13]. Suppose that a receiver i wants two messages W i = {x 1 , x 2 }, and knows K i . As far as index codes are concerned, we can replace receiver i by two receivers i and j , both knowing the same set K i , and each wanting a single message, i.e., x 1 and x 2 respectively. We can further split the receivers in a similar manner so that each message contains only a single bit.
2) Side information: We next classify different types of side information at the receivers. We say that an index coding instance is uniprior if meaning that each message is known a priori to at most one receiver. In addition, we say that the instance is single-uniprior if, in addition to (3), we also have that |K i | = 1 for all i, meaning that each receiver knows exactly one unique message a priori. Unlike unicast instances, single-uniprior instances do not subsume all uniprior instances. A receiver who knows {x 1 , x 2 } is not equivalent to two receivers each knowing only one of them.

B. Graphical representation of the receiver setting
Existing works on index coding focused on the single-sender case, and many used the following graphical representations to capture the receivers' side information and requests.
1) Unicast multiprior (or simply unicast): As mentioned above, any unicast instance can be converted into an equivalent single-unicast instance. Without loss of generality, we can assume exactly n receivers and n messages, as message not requested by any receivers can be removed. Single-unicast index-coding instances are commonly represented by sideinformation graphs [1] with n vertices {1, 2, . . . , n}, where an arc exists from vertex i to vertex j if and only if receiver i knows the message requested by receiver j. 2) Unicast uniprior: The class of index-coding instances with unicast and uniprior was investigated by Neely et al. [2], where each message bit is (i) known to only one receiver, and (ii) requested by only one receiver. Neely et al. represented this class by a weighted compressed graph, where each vertex represents a receiver, and an arc of weight q exists from vertex i to j if and only if receiver j wants q messages known to receiver i.
Although a unicast instance can be recast into a singleunicast instance, not all unicast uniprior instances can be recast into single-unicast uniprior instances. This is because if we split a receiver, there will be more than one receivers knowing the same message (i.e., the instance is no longer uniprior).
3) Multicast multiprior: This is the most general class of the index-coding instances, where there is no restriction on W i and K i . To completely capture the information in both W i and K i , Neely et al. [2] proposed a bipartite-graph representation, where there are n receiver vertices, {r 1 , r 2 , . . . , r n }, and m messages vertices, {x 1 , x 2 , . . . , x m }. An arc from r i to x j exists if and only if receiver i wants x j , and arc from x i to r j exists if and only if receiver j knows x i . Blasiak et al. [4] and Alon et al. [12] used hypergraphs to represent multicast multiprior instances.
4) Multicast single-uniprior (or simply single-uniprior): This is the class of index-coding instances considered in this paper. Without loss of generality, we consider n receivers and n messages. This subsumes the case where a message x j is not known to any receiver. To see this, add a dummy receiver n + 1 who knows x j but does not want any message. Clearly, adding this receiver does not change the problem.
Side-information graphs used for single-unicast instances cannot capture all single-uniprior instances. We illustrate this using the example below: Example 1: Consider the following uniprior instance: where each message x i contains one bit. We will see later (Corollary 1) that the optimal index codelength for this instance is three bits. If we apply the rule for constructing side-information graphs that says "i → j exists if receiver i knows the message requested by receiver j", we get graph G 1 shown in Figure 2. For a unicast instance represented by G 1 , the optimal codelength is two bits (using clique cover [11]). Thus, G 1 incorrectly represents the uniprior instance described here. However, since receivers 3 and 4 request multiple messages, we can obtain an equivalent instance by splitting receiver 3 to two receivers (say, 3 and 5), each knowing the same message but requesting a different message: We similarly split receiver 4: Constructing a side-information graph for this equivalent instance, we get G 2 in Figure 2. But for a unicast instance represented by G 2 , the optimal codelength is four bits (again, using clique cover). Thus G 2 again incorrectly represents the uniprior instance in this example. The reason is that sideinformation graphs are not able to capture multiple receivers requesting a same message.
Instead, we propose information-flow graphs with n weighted vertices. Without loss of generality, let K i = {x i } for all receiver i ∈ {1, 2, . . . , n}. An arc exists from vertex i to vertex j if and only if node j wants the message known to receiver i, i.e., x i ∈ W j . The weight of vertex i is q i , which is the number of bits in message x i . Although a uniprior instance can be represented by either a hypergraph or a bipartite graph, using the information-flow graph results in a smaller (compare to the bipartite graph) and simpler (a directed graph instead of a hyper graph) graph.

C. Graphical representation of the sender setting
When there are multiple senders, we need to represent {M s } in addition to {q i , K r , M r }. We propose to represent {M s } using an n-vertex undirected message graph, denoted by U. An edge between vertices i and j on U (denoted by (i, j)) exists if and only if messages x i and x j are known to the same sender, i.e., i, j ∈ M s for some s.
In this paper, we will consider multi-sender single-uniprior instances each described by an information-flow graph G and a message graph U, both defined on the same set of vertices V = {1, 2, . . . , n}. We denote by˜ * (G, U) the optimal index codelength for the instance represented by (G, U).
Note that an edge (i, j) in U does not indicate which sender(s) owns both the messages (i.e. the set of s such that i, j ∈ M s ). This ambiguity will not affect the techniques developed in this paper. In fact, for some cases, this is sufficient to derive the optimal index codelength. However, we will point out in the conclusion the existence of an instance where resolving this ambiguity can further improve our results.

IV. EXISTING RESULTS AND OUR CONTRIBUTIONS
In this section, we will survey existing results on * for the single-sender problem. We will then review related works on multiterminal networks with side information that have settings similar to that in the multi-sender index-coding problem. Lastly, we present the main results of this paper.

A. Existing results for single-sender index coding
Recall that any unicast instance can be first converted to an equivalent single-unicast instance with binary messages and then represented by a side-information graph. For binary messages, Bar-Yossef et al. [1] found the optimal index codelength * for all acyclic side-information graphs. Suppose that a side-information graph has cycle(s) and is symmetrical (meaning that for every arc from vertex i to vertex j, there is another arc from vertex j to vertex i). For this special case, the directed side-information graph can be converted to an undirected graph where an edge between vertices i and j represent the arcs in both directions. Bar-Yossef et al. solved all unicast index-coding instances with the following undirected side-information graphs: (i) perfect graphs, (ii) odd holes with five or more vertices, and (iii) odd anti-holes with five or more vertices.
Arbabjolfaei et al. [3] found * for all unicast instances up to five receivers. They used random-coding arguments to prove achievability. Later, Ong [5] showed that binary linear codes are sufficient to achieve * for all unicast instances up to five receivers. Blasiak et al. [4] and Thapa et al. [24] found * for certain special classes of graphs.
Also for unicast instances, using the bipartite-graph representation, Yu and Neely [6] showed that if the graph is planar, 3 then * can be found using linear programming (solutions not in closed form). This class of unicast instances subsume all unicast uniprior instances up to four receivers as special cases. Neely et al. [2] found * for unicast uniprior instances if the weighted compressed graph contains only arc-disjoint cycles.
For the most general multicast multiprior case, Neely et al. [2] found * for all acyclic bipartite graphs.
It has been shown [14] that (i) the general multicast multiprior index-coding problem is NP-hard, and (ii) the multicast (non-unicast) index-coding problem is even NP-hard to approximate.
For all the above-mentioned classes of index-coding instances where * has been found, linear index codes are optimal. However, for some single-unicast instances, Lubetzky and Stav [7] showed that non-linear index codes can outperform linear codes.

B. Related works on multiterminal networks with side information
In the literature, a problem setup related to the multi-sender index-coding problem is multiterminal networks where a set of clients exchange messages directly through a shared noiseless medium. The aim is to minimize the total transmission cost (e.g., total number of transmissions) while satisfying all clients' requirements. This problem can be viewed as a special case of the multi-sender index-coding problem where for each client, there is a sender having the same messages.
Ozgul and Sprintson [27] considered this setup where each client requests all the messages it does not know. They used multiple rounds of random linear coding to achieve the optimal transmission cost with high probability.
Hou, Hsu, and Sprintson [28] considered the same setup where each client requests one message (i.e. unicast), and it is selfish in the sense that it tries to minimize its own transmissions. They proposed a game-theoretic algorithm (via bidding) for transmission, and numerically showed that their algorithm is close to optimal.
Ji, Caire, and Molisch [29] also considered this setup where the side information of the clients (which admits a fixed number of bits) can be chosen, but the requests (also with a fixed number of bits) are random variables. They obtained an upper  TABLE I  A SUMMARY OF OUR TECHNIQUES USED TO OBTAIN DIFFERENT BOUNDS IN THIS  bound and a lower bound (on the optimal rate, i.e., total transmitted bits per side-information bits per client) within a multiplicative gap, by carefully designing the client's side information, such that all requests can be fulfilled by their transmission scheme. Unlike the setup considered by Ji et al., the setup in this paper does not allow one to design the side information of the receivers. Also, unlike the setups by Ozgul and Sprintson, and Hou et al., we consider all possible message requests by the receivers.
C. Our contributions 1) Single-sender: In this paper, we solve all single-uniprior (including unicast and multicast) index-coding problems, and show that the solution can be found in polynomial time in the worst case.
More specifically, we characterize the minimum codelength * of any single-uniprior index-coding instance in terms of the number of leaf non-trivial strongly connected components (SCC) of the corresponding information-flow graph G. To this end, we design a pruning algorithm that removes arcs from G to "destroy" all leaf non-trivial SCCs, to get a graph through which we derive a lower bound on * . By carefully pruning G, we show that the lower bound is achievable using linear cyclic codes. Hence, we incidentally show that linear index codes are optimal for all single-uniprior instances. This is in stark contrast to the single-unicast instances where non-linear codes can outperform linear codes [7].
For the rest of this paper, when we say leaf SCCs, we simply mean leaf non-trivial SCCs.
2) Multi-sender: For multi-sender single-uniprior instances, we construct upper and lower bounds on the optimal index codelength based on the information-flow graph G and the message graph U. For the lower bound, we construct an algorithm that not only prunes G (using the aforementioned pruning algorithm), but also adds arcs, edges, and vertices, and derive a lower bound on˜ * through the resultant graph. For the upper bound, we first define a special type of tree, and we count the number of such trees that we can fit into the graph. We then propose a coding scheme for each tree and some leaf SCCs to obtain a linear index code.
We will show that our upper and lower bounds match for a class of multi-sender single-uniprior instances. This class includes as a special case the scenario where no two senders know the same message, i.e., M s ∩ M t = ∅ for all s = t.
3) Summary of results and techniques: Table I shows the sections in which we derive different bounds and the techniques involved. Figure 3 summarizes our results in relation to other results.

V. THE SINGLE-SENDER SINGLE-UNIPRIOR CASE
In this section we focus on the single-sender single-uniprior case. We will propose a pruning algorithm to obtain a lower bound on * , and then construct a linear index code that achieves this lower bound.
For the single-uniprior case, we work on the informationflow graph, denoted by G = {V, A}, where V = {1, 2, . . . , n} is the set of vertices, and A is the set of arcs. This models an index-coding instance where there are n receivers, and each receiver i knows x i a priori and requests {x j : (j → i) ∈ A}. For the remaining of this paper, we refer to the message x i , known to receiver i, simply as the message of vertex i. Let * (G) denote the optimal index codelength for a single-sender uniprior instance represented by G.
A. Lower bound 1) Useful lemmas: We first establish a few lemmas, which we will use to establish our lower bound.
Lemma 1: Each receiver i ∈ V must be able to decode the messages of its predecessors in G.
Proof: An index code always allows receiver i to decode x j if an arc (j → i) exists. In the single-uniprior instance, x j is all the side information receiver j has. Therefore, receiver i must also be able to decode all the messages that receiver j is able to decode, i.e., receiver i can decode all W j = {x k : (k → j) ∈ A}. Further chaining of this argument proves that receiver i must be able to decode the messages of the predecessors of vertex i.
Lemma 2: Every receiver can decode the messages of all predecessors of any leaf vertex, even without utilizing its prior message.
Proof: Consider any leaf vertex i, its prior message x i is not requested by any receiver. So, we can arbitrarily set x i = 0 without affecting the decoding of any receiver, or the codelength. With this, any receiver (even one without any side information) knows x i = 0, and, by Lemma 1, it must be able to decode all predecessors of the leaf vertex i. Since the choice of the leaf vertex was arbitrary, we conclude the proof.
2) A simple lower bound: Define the set of leaf vertices in G as L(G). We have the following from Lemma 2: Lemma 3: For any graph G, we have * (G) ≥ i: i is a predecessor of some vertex in L(G) Proof: Denote the messages of all predecessors of all leaf vertices by X {X i : i is a predecessor of some vertex in L(G)}, 4 and the index code by C. It follows from Lemma 2 that any receiver can decode X from C, i.e., H(X|C) = 0, or H(X, C) = H(C), where H(·) is the entropy function.
where Q is the right-hand side of (4). Equality (a) is derived because the messages are independent, and (b) is derived because each message bit is uniformly distributed.
The lower bound in Lemma 3 is not useful when the graph G contains not many predecessors of leaf vertices. For example, the right-hand side is zero if G is a cycle. In light of this, we "process" the graph to obtain a better lower bound in the following subsection.
3) A better lower bound: We observe the following: Proof: Removing arcs in an information-flow graph reduces decoding requirements, while maintaining the prior 4 We use upper-case letters to denote random variables. messages of each receiver. This means any index code for G is also an index code for G .
Combining Lemmas 3 and 4 gives the following lower bound: Lemma 5: Given any G = {V, A}, the optimal index codelength of a single-sender single-uniprior index-coding instance represented by G is lower bounded as The lower bound in Lemma 5 involves maximizing q i over all arc-removed subgraphs G . We now present a way to optimally remove arcs, to attain the right-hand side of (6). To this end, we propose an algorithm to remove certain arcs to obtain a lower bound. Then, in the next section, we will show that this lower bound is indeed achievable, thereby proving that the bound obtained using this algorithm is tight, i.e., that it attains the right-hand side of (6).
We first define the following: Definition 2: A leaf SCC is a non-trivial 5 SCC that has no outgoing arc (i.e., from a vertex in the SCC to a vertex outside the SCC).
We now present a lower bound, which is essentially Lemma 5 evaluated with a specific G : Theorem 1 (Single-sender: lower bound): The optimal index codelength of a single-sender single-uniprior index-coding instance is lower bounded as (2) , . . . } is the set of all leaf SCCs in G.
We defer the proof of Theorem 1 to Section V-A4, after introducing a pruning algorithm.

Remark 1:
The lower bound here is more general than the result in our previously-published conference paper [15], for which the messages are restricted to be the same size. 4) Proving Theorem 1 using a pruning algorithm: We start with the following definitions: Definition 3: A vertex is said to be grounded if it is either a leaf vertex, or a predecessor of some leaf vertex.

Definition 4:
A graph is said to be grounded if every vertex in the graph is grounded.
Lemma 6: The two statements below are equivalent for any directed graph G: We now propose an arc-removing algorithm, called the pruning algorithm, which we will use to prove Theorem 1.
Executing the pruning algorithm gives the following result: Arbitrarily select a vertex with the least weight, i.e., any i ∈ argmin a∈VleafSCC q a ; Remove all outgoing arcs from vertex i, i.e., all (i → k) ∈ A; Lemma 7: Consider a graph G = {V, A}. Let the resultant graph after running the pruning algorithm be i: i is a predecessor of some vertex in L(G p ) (10) Proof: Since the algorithm only removes arcs, we have (8) and (9).
We now show that G p has no leaf SCC. Consider a leaf SCC in G for which vertex i is selected and all its outgoing arcs are removed. By definition, every vertex in the SCC has a path to i. After the foreach iteration, i is made a leaf vertex, and all vertices in the leaf SCC are therefore grounded. Also, as all SCCs are vertex disjoint, this iteration destroys one leaf SCC and does not create any new leaf SCC. When the algorithm terminates, G p has no leaf SCC, and it follows from Lemma 6 that G p is grounded.
Since G p is grounded, each non-leaf vertex is a predecessor of some leaf vertex. This means i: i is a predecessor of some vertex in L(G p ) (2) , . . . } is the set of all leaf SCCs in G. These leaf SCCs are vertex-disjoint by definition. In Algorithm 1, one vertex (one with the least weight) in each leaf SCC in G is made a leaf vertex. So, Substituting (12) into (11), we have (10). Proof of Theorem 1: Combining Lemmas 5 and 7, we have Theorem 1.
Remark 2: (Complexity of the pruning algorithm) All SCCs in a graph can be found in linear time in |V| + |A| (see, for example, the Kosaraju-Sharir algorithm [30] or Tarjan's algorithm [31]). To check if an SCC is a leaf SCC, we check whether all out-neighbors of each vertex in the SCC is in the same SCC. This takes at most |A||V| checks. Finding the vertex with the minimum message length in a leaf SCC can be done by a sorting algorithm with a worst-case complexity of |V| log |V|. So, the pruning algorithm runs in O(|V| 3 ) in the worst case.
The main idea behind our lower bound here is that removing some requests by a receiver (i.e., reducing the sets {W r }) cannot increase the optimal index codelength. This corresponds to removing arcs in the information-flow graph. A similarbut different-concept was used to derive a lower bound for the unicast index-coding instances (which are represented by side-information graphs), namely, the maximum-acylic-inducedsubgraph (MAIS) lower bound [1], [2]. The main idea behind the MAIS bound is that removing messages (i.e., reducing M and adjusting {K r , W r } accordingly) from the system cannot increase the optimal index codelength. This corresponds to a vertex-induced subgraph. While the MAIS lower bound is in general not tight for single-sender unicast index-coding instances [4], we will see that our proposed lower bound based on removing arcs is tight for all single-sender uniprior indexcoding instances.

B. Upper bound (achievability): cyclic codes
In this subsection, we construct linear index codes that achieve the lower bound given in Theorem 1. Although the lower bound is calculated based on the pruned graph G p , for achievability, we need to design index codes for the original graph G. It turns out that by coding on leaf SCCs in G, we can construct index codes that attain the lower bound.
It is easier to discuss the lower bound, i.e., the right-hand side of (7), in terms of a trivial index code and "savings". To see this, we compare it with a trivial index code that simply transmits k∈V q k − i∈L(G) q i bits, which are the uncoded messages of the non-leaf vertices (since, by definition, the messages of the leaf vertices are not requested by any receiver). We will further show that an extra savings of q a bits is possible-a consequence of the leaf SCCs. This corresponds to a savings, over the trivial index code, of min a∈VleafSCC q a bits for each leaf SCC V leafSCC ∈ V.
We will use cyclic codes, defined below, to realize the required savings: Definition 5 (Cyclic codes): Consider n q-bit messages, {x 1 , x 2 , . . . , x n }. A cyclic code is a length q(n − 1)-bit code, constructed as follows: where ⊕ bit-wise XOR.
Theorem 2 (Single-sender: upper bound): The optimal index codelength of a single-sender single-uniprior index-coding instance is upper bounded as Proof of Theorem 2: For each non-leaf vertex i that does not belong to any leaf SCC, we send x i uncoded.
For vertices in leaf SCCs, we construct the following code: Consider a leaf SCC in G, and let its vertices be V leafSCC = {1, 2, . . . , v}. For now, let us first assume all messages in the leaf SCC are of equal length, say q bits. Then construct the following cyclic code: Note that for any i ∈ V leafSCC , receiver i • can decode all messages in V leafSCC from (14) and its side information x i , • can also decode the messages of all non-leaf vertices not in any leaf SCC (as these messages are sent uncoded), and • does not request any messages in other leaf SCCs (due to the definition of leaf SCC). Repeating the above cyclic code for each leaf SCC, we satisfy the decoding requirements for all receivers in all leaf SCCs. Also, any receiver not in any leaf SCC can also decode its requested messages, as these messages are sent uncoded. Note that, by definition, messages in any leaf SCC are not requested by any receiver outside the leaf SCC.
To generalize the above to non-equal-length messages of q i bits for each vertex i, simply form (14) by substituting each x i with its first q min bits, where q min is the shortest message length in the leaf SCC, i.e., q min = min 1≤a≤v q a . Then the total number of coded bits in (14) is (v − 1)q min bits. We send the remaining bits v i=1 q i − vq min uncoded. Hence, the total savings per leaf SCC is q min .
Repeating this for each leaf SCC, we save a total of VleafSCC(j)∈V min a∈VleafSCC(j) q a bits for the entire graph G.

Remark 3:
The cyclic code (14) used in the proof of Theorem 2 can be derived from the partial-clique-cover scheme [11] (originally proposed for unicast index coding).
= M each taking values from a finite field F; (ii) a set of receivers {1, 2, . . . , n}, where each receiver i ∈ {1, 2, . . . , n} knows a priori at least k messages in M, i.e., |K i ∩ M| ≥ k. The partial-clique-cover scheme gives a codeword based on minimum-distance-separable codes with the following properties: (a) it consists of (v − k) finite-field symbols; (b) it simultaneously lets each receiver decode all messages in M. For a leaf SCC in a single-uniprior indexcoding problem, we have k = 1. By setting F = {0, 1}, and appropriately constructing a minimum-distance-separable code, one can obtain (14) for q = 1 (a codeword of (v − 1) bits), which allows all receivers in the SCC to decode all messages in the SCC. The multiple-bit version of (14) can be obtained by concatenating q > 1 copies of the binary codewords.

C. The optimal index codelength
Combining Theorems 1 and 2, we have the following: Theorem 3: The optimal index codelength of a single-sender single-uniprior index-coding instance is Furthermore, linear codes can achieve the optimal index codelength.
Example 2: We illustrate how to obtain the optimal codelength and an optimal code for an index-coding instance with one single-bit message (i.e., ] for i ∈ {2, 3, 4, 5}), and five receivers. Each receiver i knows K i = {x i }, and the receivers each request the following messages: This problem can be represented by a graph G depicted in Figure 4. It contains one leaf SCC with vertices V leafSCC = {1, 2, 3}, in which message x 1 has the shortest length of one bit. There is only one leaf vertex in G, which is node 5. Theorem 1 gives a lower bound * (G) ≥ 9 − 2 − 1 = 6. To construct an optimal index code, we form a two-bit cyclic code ) for the leaf SCC in G, and four uncoded bits for the remaining messages in the leaf SCC and the messages of the other the non-leaf vertices For the special cases where all messages are binary, Theorem 3 simplifies to the following: where |L(G)| is the number of leaf vertices in G and N leaf (G) is the total number of leaf SCCs in G.

VI. THE MULTI-SENDER CASE: A LOWER BOUND
In this section, we will modify the pruning algorithm to include information from U, and further propose an appending step to modify the graph G, based on which we derive a lower bound for the multi-sender case.
For simplicity and clarity, we will only consider the case where all messages x i are binary. This means all vertices in the information-flow graph G all have weight one. One can extend the ideas developed in this section to the more general case of unequal message sizes.
A. The single-sender bound may be loose for multi-sender Denote a multi-sender instance by (G, U). The optimal codelength˜ * (G, U) clearly is lower bounded by * (G) for the single-sender case, because a single sender who knows all the messages can also send any multi-sender index code. We also know from Lemma 3 that, for a graph G with binary messages, * (G) is lower bounded by the number of vertices that are each a predecessor of some leaf vertex, denoted by V predec (G). This gives * (G, U) ≥ * (G) ≥ V predec (G).
For the single-sender problem, we used the pruning algorithm to prune all leaf SCCs to get a grounded graph G p . As pruning does not increase the optimal codelength (see Lemma 4), we have the following single-sender bound for multi-sender instances: where V out (G) denotes the total number of non-leaf vertices in G. The equality above is derived as G p is grounded.
However, the single-sender lower bound may be loose due to the sender constraints specified by the undirected graph U (see its definition in Section III-C). Consider Example 2 again, and suppose that there are five senders, where each sender i ∈ {1, 2, . . . , 5} has only x i . Under this constraint, it is not possible to transmit x 1 [1] ⊕ x 2 [1], as the messages belong to different senders. The minimum codelength for this case is seven bits-sending [x 1 , x 2 , x 3 , x 4 ] uncoded. On the other hand, if some sender has {x 1 , x 2 } and another has {x 2 , x 3 }, then the six-bit lower bound is tight using the coding scheme mentioned in the example.

B. A tighter bound by appending
We will propose a new algorithm that gives a better lower bound. Our new algorithm produces a resultant graph, say G † , with a possibly higher number of V predec (G † ) > V predec (G p ), where G p is the resultant graph after running Algorithm 1. To obtain the desired G † , we propose a new technique that appends some leaf SCCs, by adding an outgoing arc from each of these leaf SCC to another vertex or a newly introduced grounded vertex. In the new algorithm, we iterate on the leaf SCCs (either pruning or appending) until we get a grounded information-flow graph G † . 6 From the resultant G † , we get * (G † , for all U † , where the inequalities follow from (17), and the equality is derived because G † is grounded.
To link this lower bound to the original graph (G, U), we need to make sure that the optimal index codelength cannot increase after each pruning/appending step. If this is satisfied, we have the lower bound * (G, We aim to maximize the number of non-leaf vertices in the resultant graph (which is grounded).
We will see that pruning reduces the number of non-leaf vertices by one, while appending does not change the number of non-leaf vertices. So, potentially V out (G † ) > V out (G p ), which means the lower bound (20b) is potentially tighter than (18).
We have seen in the single-sender case that (20a) is always true if we prune all leaf SCCs. However, appending in general increases decoding requirements, which may cause the optimal index codelength to increase. The main challenge here is to append certain types of leaf SCCs such that the optimal index codelength cannot increase, i.e., (20a) holds. To this end, we will classify leaf SCCs based on U.

C. Classifying leaf SCCs to reflect the sender setting
We now give some intuition on how we use U to classify the leaf SCCs. Recall that U is an undirected graph where an edge exists between vertices i and j, if and only if some sender has both x i and x j . Connectivity in U restricts the construction of index codes, which allows us to append some leaf SCCs. For example, if there is no path between two vertices in U, say vertices 1 and 2, then it turns out that we can partition any index codeword into two sub-codewords, where one sub-codeword is a function of only messages from a set, say M ⊂ M, containing x 1 , and the other sub-codeword a function of the only messages from the set M \ M , which contains x 2 . This, we will show, leads to the result that any receiver can decode all messages in a leaf SCC that contains two vertices not connected in U. As a consequence, we can append this type of leaf SCC, while satisfying (20a), by adding an arc from the leaf SCC to a dummy vertex.
We will now formally classify different types of leaf SCCs based on their connectivity in U. We first define neighboring vertices in U. For a vertex set V S ⊆ V, we say that a vertex i / ∈ V S is a neighbor of V S if and only if there is an edge (i, v) in U between i and some v ∈ V S . 1) Message-connected leaf SCC: A leaf SCC in G is said to be message-connected if and only if there always exists a path 7 in U between any two vertices in the SCC, where the path consists of vertices only in the SCC. 2) Message-disconnected leaf SCC: A leaf SCC is message-disconnected if and only if there are two vertices in the SCC with no path in U between them (even if the path can contain vertices outside the SCC).

3) Semi-message-connected leaf SCC A leaf SCC that is
neither message-connected nor message-disconnected is semi-message-connected, referred also as semi leaf SCC for short. Here, we can always find a vertex pair, where all paths between them must contain some vertex outside the SCC. We further classify semi leaf SCCs: a) Degenerated leaf SCC: A semi leaf SCC, with vertex set V S , is said to be degenerated if and only if we can find two vertex sets

b) Non-degenerated leaf SCCs: A semi leaf SCC that
is not degenerated is said to be non-degenerated. Any leaf SCC must belong to one of these four types. Figure 5 shows examples of three types of leaf SCCs. As cryptic as the definition of a degenerated leaf SCC may seem, it has been carefully crafted to allow us to append it.

D. Which leaf SCCs to append and which to prune?
Recall that our lower bound is given by˜ * (G, U) ≥ V out (G † ), and we want the resultant grounded information-flow graph G † to have as many non-leaf vertices as possible. As mentioned before, we would prefer appending to pruning, as the latter always reduces the number of non-leaf vertices, but the former does not. However, for message-connected and nondegenerated leaf SCCs, we are unable to show that appending will not increase the optimal index codelength, as required by (20a). In fact, appending a message-connected leaf SCC can strictly increase the optimal index codelength, as shown by the following example: Example 3: Consider a single-uniprior index-coding instance, whose information-flow graph is given by 1 2 and a sender has both the messages. Here, the graph itself is a message-connected leaf SCC. The optimal codelength is one, attained by x 1 ⊕ x 2 . The single-sender lower bound * (G, U) ≥ 1 is tight. If we append (we will formally define the appending step in the next section) this leaf SCC, by creating a dummy vertex 3, and an arc (2 → 3), the resultant grounded graph G † is 1 2 3 and we get˜ * (G † , U † ) ≥ V predec (G † ) = 2. For this example, (20a) is not true, and V predec (G † ) is not a lower bound oñ * (G, U). So, we will • prune message-connected and non-degenerated leaf SCCs, and • append message-disconnected and degenerated leaf SCCs. In the following three subsections, we will prove that appending message-disconnected and degenerated leaf SCCs indeed guarantees (20a). We will also derive the number of non-leaf vertices after each pruning/appending step, and show that the number of leaf SCCs that remain in the graph cannot increase (so that our algorithm always terminates).
We will use the following notation. Let G and U be the information-flow graph and the message graph (respectively) before a pruning/appending step, and G and U be the respective graphs after the step.
1) Appending a message-disconnected leaf SCC: Definition 6 (Appending a message-disconnected leaf SCC): To append a message-disconnected leaf SCC (with a vertex set V S ), we add • a dummy vertex n + 1 in both G and U where x n+1 = 0, which is known to all receivers and is hence never transmitted by the sender, and • a dummy arc in G from an arbitrarily chosen vertex in the leaf SCC to the dummy vertex, i.e., choose some v ∈ V S and add (v → n + 1) in G.

Proposition 1:
After appending a message-disconnected leaf SCC, we have Proof: See Appendix B. 2) Appending a degenerated leaf SCC: Recall that a semi leaf SCC (with vertex set V S ) is degenerated if and only if we can find two vertex sets, V inside S in the SCC and V outside S outside the SCC, as per the definition given in Section VI-C. We append a degenerated leaf SCC as follows: Definition 7 (Appending a degenerated leaf SCC): To append a degenerated leaf SCC, first pick any vertex in V inside S , say v inside . We then add an arc according to the following two possibilities: • Case 1: If V outside S contains exactly one non-leaf vertex, add an arc from v inside to the non-leaf vertex.
Proof: See Appendix C. 3) Pruning a leaf SCC: The pruning step in the multi-sender case is the same as the single-sender case. Since we assume that all the messages are binary, we can choose any vertex from which we prune its outgoing arcs. Formally, we have the following: Definition 8 (Pruning a leaf SCC): To prune a leaf SCC, with vertex set V S , we arbitrarily select a vertex v ∈ V S , and remove all outgoing arcs from v.

Proposition 3: After pruning a leaf SCC, we have
Proof: The pruning step grounds all the vertices in the leaf SCC, and does not change the connectivity of other vertices outside the leaf SCC. This gives (28).
As removing arcs reduces decoding requirements, any index code for (G, U) also satisfies the decoding requirement for (G , U ). So, we have (29).
As we remove all outgoing arc from a non-leaf vertex, we have (30).

E. Constructing an algorithm by pruning and appending
We are now ready to assemble the pruning and appending steps to form an algorithm that returns a grounded informationflow graph G † .
From the previous section, we know that each step increases neither the optimal index-codelength nor the number of leaf SCCs. In fact, we have the following lemma: Lemma 8: We can always get a grounded information-flow graph after a finite number of pruning and appending steps on all the leaf SCCs.
Proof: Consider an algorithm that recursively (i) appends a message-disconnected or a degenerated leaf SCC, and (ii) prunes a message-connected or a non-degenerated leaf SCC. We now show that the algorithm always terminates after a finite number of steps.
From Propositions 1, 2, and 3, the number of leaf SCCs always (i) decreases by one, or (ii) remains the same (In this case, the leaf SCC assimilates one or more vertices that do not belong to any leaf SCC. See Appendix C for proof.) after each pruning/appending step. The pruning/appending step that results in case (i) can be executed at most n/2 times as there are at most n/2 leaf SCCs in a graph. The pruning/appending step that results in case (ii) can be executed at most n − 2 times, as this step requires a leaf SCC to start with (which must contain at least two vertices), and there are at most n − 2 vertices that does not belong to any leaf SCC.
So, the algorithm will terminate after at most 3n/2 − 2 appending/pruning steps. Figure 6 depicts our algorithm to find a lower bound oñ * (G, U).

F. Obtaining a lower bound
The algorithm depicted in Figure 6 returns possibly different lower bounds, V out (G † ), depending on which leaf SCC is selected in each iteration. We give an example to show this, after proving the following lemma: Lemma 9: A non-degenerated leaf SCC may become degenerated after appending/pruning other leaf SCCs.
Proof: Although no new leaf SCC is created after each appending/pruning step, more vertices may be grounded, and some non-degenerated leaf SCCs may become degenerated as the degeneration conditions are satisfied with more grounded vertices.
Example 4: Consider the index-coding instance depicted in Figure 7. The directed subgraph induced by vertices {1, 2} is a message-connected leaf SCC, that by {3, 4} non-degenerated, and that by {5, 6} degenerated. Suppose that we first prune the non-degenerated leaf SCC {3, 4}, followed by pruning the message-connected {1, 2}, and then appending the degenerated {5, 6}. This pruning/appending sequence gives a resultant grounded graph with V out (G † ) = 4. However, if we append {5, 6} and prune {1, 2} first, {3, 4} will be made degenerated and will be appended instead. This gives a different G † with a higher V out (G † ) = 5. To obtain the tightest lower bound using the algorithm in Figure 6, we perform the following combinatorial optimization: Theorem 4 (Multi-sender: lower-bound): The optimal indexcodelength for a multi-sender index-coding instance represented by (G, U) is lower bounded as * (G, where G † is the resultant graph after running the algorithm depicted in Figure 6, and the maximization is taken over all possible sequences of pruning/appending the leaf SCCs in the algorithm.

G. Another lower bound using a heuristic algorithm
The lower bound obtained by the combinatorial optimization in Theorem 4 has some implementation issues: • For a large number of leaf SCCs, the optimization runs in factorial time in the number of leaf SCCs.
• It provides little insights to when the algorithm is optimal (i.e., giving a tight lower bound), and how good the algorithm is (whether we can bound the gap between the optimal index codelength and the lower bound).
In light of these issues, we design a heuristic algorithm. We first prove the following lemma: Lemma 10: The status of a leaf SCC being messageconnected, message-disconnected, or degenerated is not affected by the appending/pruning of other leaf SCCs.
Proof: See Appendix D. Lemma 10 suggests that it does not matter in what order we prune or append message-connected, message-disconnected, or degenerated leaf SCCs. At the end, all message-connected leaf SCCs will be pruned, and all message-disconnected and degenerated leaf SCCs appended. 8 It matters, however, in which order we process nondegenerated leaf SCCs. As pointed out in the previous section, having more grounded vertices increases the chances of a nondegenerated leaf SCC become degenerated for which we can append (instead of pruning it in the event that it stays nondegenerated). We will design a heuristic algorithm that leaves the pruning of the non-degenerated leaf SCCs to the last-we ground the rest as far as possible. This heuristic algorithm is shown in Figure 8. Note that this heuristic algorithm is a one-pass algorithm which does not iterate over operating different sequences of leaf SCCs.
While the heuristic algorithm in Figure 8 produces a grounded G † that we require, we re-write the algorithm in a slightly different way, as Algorithm 2, which leads to a lower bound (see Theorem 5) in a form similar to the upper bound to be derived in Theorem 6 later. Having similar forms, we will then identify classes of (G, U) for which the bounds match.
We now describe the idea behind Algorithm 2. Our lower bound, V out (G † ), relates to the number of non-leaf vertices in the original graph G via (23), (27), and (30). We see that we only need to count the number of pruning steps. So, we design Algorithm 2 such a way that we • identify and count each pruning step, • separate the pruning of message-connected leaf SCCs in the original graph G out in the Initialization phase (so that we can express the lower bound as a function of G), • process non-degenerated leaf SCCs last (after processing all other types of leaf SCCs). The Initialization and Iteration phases are the same except that we only prune non-degenerated leaf SCCs in the latter, after pruning and counting all message-connected leaf SCCs in G.
Note that any leaf SCC being operated is destroyed except for degenerated leaf SCCs (see Appendix C). In this case, the degenerated leaf SCC may assimilate other vertices to form a larger leaf SCC, which can be of any type, depending on how the new leaf SCC is connected in U. The type of this newly-formed leaf SCC is to be identified during runtime.
After running Algorithm 2, we obtain the following lower bound: Theorem 5 (Multi-sender: lower bound): The optimal index codelength for a multi-sender index-coding instance represented by (G, U) is lower bounded as where N msg-conn (G, U) is the number of message-connected leaf SCCs in G, and N iteration is the number of times Iteration repeated in Algorithm 2.
Remark 4: From (32c), we note that the lower bound depends on the number of times Iteration is executed. In each iteration, the choice of which non-degenerated leaf SCC to prune will affect the lower bound. As a rule of thumb, we prune a non-degenerated leaf SCC that will degenerate other nondegenerated leaf SCCs, so as to reduce the number of Iterations.

VII. THE MULTI-SENDER CASE: AN UPPER BOUND
We now derive an upper bound, via a coding scheme, by constructing special trees in the message graph U, referred to as connecting trees. The vertex set of a connecting tree, denoted by V T , has the following properties: 1) Each vertex in V T has one or more outgoing arcs in G, and only to other vertices in V T . This means V T has no outgoing arc to V \ V T , 2) No vertex in V T belongs to any message-connected leaf SCCs or another connecting tree. Let N tree (G, U) denote the number of connecting trees that can be found for a given instance (G, U). We will propose a coding scheme that achieves the following index codelength: Theorem 6 (Multi-sender: upper bound): The optimal index codelength for a multi-sender index-coding instance represented by (G, U) is upper bounded as Fig. 9. An index-coding instance represented by G (with arcs) and U (with edges). There are two leaf SCCs in the graph: (i) message-connected, and (ii) degenerated. Here, we can form a connecting tree using the hollow vertices.
The upper bound is optimized by finding the maximum number of connecting trees.
For example, consider the graphs in Figure 9. We can form one connecting tree using the hollow vertices.
Proof of Theorem 6: To simplify notation, we will show that there exists an index code of length V out −(N msg-conn +N tree ), where we have dropped the arguments as they are clear from the context. Let a set of connecting trees be {T t = (V T t , E T t ) : t ∈ {1, 2, . . . , N tree }}, and all the message-connected leaf Denote by V out the set of all nonleaf vertices in V . By definition, all V T t , V C c , and V are disjoint. Our coding scheme is as follows: i.e., we transmit the XOR of the associated message pair for each edge. Note that we transmit |V T t | − 1 bits. 2) For each message-connected leaf SCC (V C c , A C c ) (which is edge-connected by definition), we first obtain a spanning tree in U, denoted by We then transmit all {x i ⊕ x j : (i, j) ∈ E ST c }. Note that we transmit |V C c | − 1 bits. 3) For the rest of the non-leaf vertices, we transmit {x i : i ∈ V out }, i.e., we transmit the message bits uncoded. Each vertex in the connecting trees and the message-connected SCCs has at least one outgoing arc. Hence, the coding scheme generates an index code of length V out − (N msg-conn + N tree ).
We can easily verify that the index code can be transmitted, as each message pair to be XORed is associated with an edge, i.e., both the message bits belong to some sender.
Finally, we show that each receiver is able to obtain its requested messages. Recall that each receiver i needs to decode all messages in {x j : (j → i) ∈ A}. Now, each receiver i must belong to one-and only one-of the following groups: t } by traversing the tree (which is connected by definition). It can also decode the messages {x k : k ∈ V out }, sent uncoded. Since all connecting trees and message-connected leaf SCCs have no outgoing arcs, each incoming arc to i must be from either V T t \ {i} or V out . So, receiver i is able to decode all its requested messages. 2) (Message-connected leaf SCC) i ∈ V C c : Using the same argument as that for the connecting trees, we can show that receiver i can decode all its requested messages. show the initialization step where the message-connected leaf SCC is pruned (by removing the dashed arc in (a)) and the degenerated leaf SCC is appended (by adding the dashed arc in (b)), respectively. Subfigure (c) shows the final graphs after the algorithm terminates.
3) (The remaining vertices) i ∈ V : Using the argument in point 1, all incoming arcs to vertex i must come from V out \ {i}. Since we sent {x j : j ∈ V out } uncoded, receiver i can decode all its requested messages.
VIII. SPECIAL CASES WHERE THE BOUNDS ARE TIGHT AND AN EXAMPLE Combining Theorems 5 and 6, we conclude N iteration ≥ N tree (G, U), and thus the optimal index codelength is found within N iteration − N tree (G, U) bits. Recall that N iteration is the number of times Iteration repeated in Algorithm 2, and it is upper bounded by the number of leaf SCCs in G that are not message-connected. In the following special cases, we have N iteration = N tree (G, U), and the lower bound is tight.
Corollary 3: If each bit x i in the message set M is known to only one sender (i.e., the n sender constraint sets M s partition M), then the optimal index codelength is given by (34).
Proof: If messages x i and x j belong to some sender s (i.e. x i , x j ∈ M s ), then there exists an edge (i, j) in the message graph U. Otherwise, if the messages x i , x j belong to different senders, it is impossible to have a path between i and j. This means we have only message-connected or -disconnected leaf SCCs, i.e., there is no semi leaf SCC. Thus, N iteration = 0.
Corollary 3 includes the result of the single-sender instance [15] as a special case.
Note that the scenario in Corollary 3, where the senders' message sets do not overlap, cannot be trivially solved by splitting the multi-sender instance into multiple single-sender instances, where each instance consists of the messages known to one sender. We illustrate this with an example in Appendix E.  Fig. 11. An example where the optimal index codelength * = 4 is achievable by XOR of three bits

A. An example
We now illustrate the lower bound and the achievability for the graph in Figure 9. For lower bound, we run Algorithm 2 to obtain the resultant graph shown in Figure 10(c). Specifically, starting from Figure 9, note that the furthest-left four vertices form a message-connected leaf SCC. We prune this leaf SCC by removing all outdoing arcs from an arbitrarily selected vertex. This results in Figure 10(a), where we remove the outgoing arc (dashed arc) from a. Now, the two middle vertices forms a degenerated leaf SCC. We append this leaf SCC by adding an arc (indicated by the dashed arc in Figure 10(b)) from v inside to v outside . This completes the initialization step.
Entering the iteration stage, we note that the right three vertices in Figure 10(b) now form a message-connected leaf SCC. We prune this leaf SCC by removing all outgoing arc(s) from the arbitrarily selected vertex v outside . The algorithm terminates here, after destroying all leaf SCCs. From Theorem 5, we have the lower bound˜ * ≥ 7 − (1 + 1) = 5.
For achievability, recall that we can form a connecting tree using the three hollow vertices in Figure 9. So, Theorem 6 gives the upper bound˜ * ≤ 7 − (1 + 1) = 5.
In this example, we have a scenario where N iteration = N tree (G, U) = 1, and hence both the lower and upper bounds are tight, giving the optimal index codelength of five bits. This example illustrates that the upper and lower bounds can coincide even if N iteration > 0 (cf. Corollary 2).

IX. DISCUSSIONS AND FUTURE WORK
We now show that the pairwise linear coding proposed in Section VII can be suboptimal. Consider an index-coding instance with six messages and six receivers, with and four senders having the following messages ( The graphical representation is depicted in Figure 11. In this example, there is no message-connected, message-disconnected, or degenerated leaf SCC in G. Running Algorithm 2, we get the lower bound˜ * ≥ 4. We can also show that the largest N tree = 1, i.e., the pairwise linear coding (Theorem 6) can only achieve 5 bits. However, if each sender sends the XOR of its three message bits, the 4-bit lower bound is achievable.
This example illustrates that-in stark contrast to the single-sender case-the pairwise coding scheme described in Section VII is not always optimal. It also shows a disadvantage of using U: it cannot differentiate a sender having (x 1 , x 2 , x 3 ) from three senders having (x 1 , x 2 ), (x 2 , x 3 ), and (x 1 , x 3 ) respectively. For future work, we will investigate a more general coding scheme and a more informative graphical representation.

APPENDIX A A GRAPH CONTAINS NO LEAF SCC IF AND ONLY IF IT IS GROUNDED
Every directed graph with no leaf SCC is grounded: Given any graph G, we form a supergraph G s by replacing each (leaf or non-leaf) SCC with at least two vertices by a special vertex, referred to as a supernode. First, G s cannot contain any directed cycle. Otherwise, all supernodes and vertices in the cycle form an SCC, and it would have been collapsed into a supernode. Since G s is acyclic, a path from any node/supernode must terminate somewhere. Now, if the G has no leaf SCC, then G s has no leaf supernode, and any path must terminate at a regular (i.e., non-supernode) leaf vertex.
Every grounded directed graph has no leaf SCC: This is easily seen by the fact that all vertices in the leaf SCC cannot be grounded, because these vertices can only reach vertices within the same leaf SCC, all of which are non-leaf.

APPENDIX B PROOF OF PROPOSITION 1
The proof of Proposition 1 requires the following lemma. We defer the proof of this lemma to after that of the proposition.
Lemma 11: From any index code, any receiver is able to decode the messages of any message-disconnected leaf SCC.
Proof of Proposition 1: We first show that (21) holds. The appending step adds a dummy leaf vertex and an arc from the message-connected leaf SCC to the dummy vertex. This grounds all vertices in the leaf SCC, and the leaf SCC is no longer a leaf SCC. The connectivity of all other vertices outside the leaf SCC is unchanged. So, this appending step neither creates any new leaf SCC nor destroys any other existing leaf SCC. Hence the number of leaf SCCs decreases by one after this step. We have (21).
Next, we show that (22) holds. Adding the arc (v → n + 1) now additionally requires the dummy receiver to decode messages in the appended leaf SCC, so˜ * (G , U ) ≥˜ * (G, U). But as the appended leaf SCC is message-disconnected, Lemma 11 above says that its messages can be decoded without using any side-information. Hence, the dummy receiver can decode its required message defined in G even using the index code for the original graph (G, U). We have (22).
Finally we show (23). A new arc is added from v ∈ V S to a newly added dummy vertex n + 1. Vertex v already had at least one outgoing arc before the appending step, and n + 1 is a leaf vertex. So, we have (23).
It still remains to prove Lemma 11.
Proof of Lemma 11: Let V S be the vertex set of a messagedisconnected leaf SCC. By definition, there are two vertices a, b ∈ V S that are not connected by any path in U. Let V a be a set of all vertices connected to a, and V b V \ V a . This means a ∈ V a , b ∈ V b , and there is no edge across V a and V b .
The lack of edge-connectivity (in U) between V a and V b implies that any index code can be partitioned into two parts (or subcodes), c = (c a , c b ), such that every bit in c a depends on only {x i : i ∈ V a } and not on {x j : j ∈ V b }, and vice versa. This means the random variables X a and (C b , X b ) are independent, even given C a . 9 In other words, forms a Markov chain. Intuitively, the parts c a (which contains x a ) and c b do not have any message bit in common. Then it must be true that receiver a decodes x b using only the part c b , i.e., without using its prior message x a , which appears only in the other separate part c a (its prior messages x a can help receiver a to decode messages only in c a ). Hence, if receiver a can decode x b , so can any receiver-even one without any prior message.
We now prove this formally. Since a and b belong to an SCC, receiver a must decode x b from the index code c and its prior information x a (see Lemma 1). This means Here, (36c) is due to the Markov chain (35). Equation (36d) means that any receiver can obtain x b from the index code alone. Consequently, any receiver can also decode the messages of all predecessors of b (using the argument in the proof of Lemma 1), which include all messages in the message-disconnected leaf SCC. We have Lemma 11.

APPENDIX C PROOF OF PROPOSITION 2
Let the appended arc be (v inside → v outside ). Unlike appending a message-disconnected leaf SCC, here, we change the connectivity of some vertex outside the leaf SCC, i.e., v outside , by creating an incoming arc to it.
The following lemma will be used to prove Proposition 2. Lemma 12: Consider the appending step in Definition 7 for a degenerated leaf SCC with some chosen V inside S and v outside . From any index code for (G, U) (the problem instance before the appending step), receiver v outside must be able to decode all messages in V inside Intuitively, any advantage in decoding x b that receiver a has over receiver v outside is due to knowing x a , but x a can help receiver a only in decoding the messages in c 1 , which receiver a can then use to decode the messages in c 2 (which contain x b ). As receiver v outside is able to decode the prior messages of N (V inside S ), which contains all the overlap of messages in c 1 and c 2 , receiver v outside is as capable as receiver a in decoding We now prove this formally. Recall that C 2 is a function of only messages (X V inside S , X N (V inside S ) ), where X S {X i : i ∈ S} for some set S; C 1 can be written as a function of ( ). Clearly, we have , C 2 , C 1 ) = 0. (37g) Here, (37a) is due to the independence of the messages, (37c) is derived because conditioning cannot increase entropy, and C 2 is a function of only messages (X V inside S , X N (V inside S ) ), (37d) and (37g) follow from the non-negativity of conditional mutual information, (37f) is derived because conditioning cannot increase entropy, and C 1 is a function of (X N (V inside S ) , X V remaining ). Equation (37g) implies that forms a Markov chain. Since a ∈ V remaining and b ∈ V inside S , also forms a Markov chain.
Since a and b are both in the leaf SCC, receiver a must be able to decode x b from the index code and its prior information x a , i.e., H(X b |C 1 , C 2 , X a ) = 0 (40a) ⇒ H(X b |C 1 , C 2 , X a , X voutside , X N (V inside S ) ) = 0 (40b) ⇒ H(X b |C 1 , C 2 , X voutside , X N (V inside S ) ) = 0 (40c) ⇒ H(X b |C 1 , C 2 , X voutside ) = 0. (40d) Here, (40b) is derived because conditioning cannot increase entropy, (40c) is due to the Markov chain (39), (40d) is due to X N (V inside S ) being a deterministic function of (C 1 , C 2 , X voutside ) because receiver v outside can decode X N (V inside S ) (which are the messages of the predecessors of vertex v outside ). Equation (40d) implies that knowing x voutside , receiver v outside can decode x b . Using the argument in the proof of Lemma 1, receiver v outside must be able to decode all messages in the leaf SCC.
Proof of Proposition 2: First, we show that either (24) or (25) must hold.
Consider Case 2 in Definition 7. Similar to the proof of Proposition 1, adding the arc causes the original leaf SCC V S to become non-leaf. Furthermore, all other leaf SCCs do not change their status, since v outside is a leaf vertex and cannot belong to any leaf SCC. So, we get (25).
For Case 1 in Definition 7, there are three possibilities: v outside is • Grounded: This case is similar to Case 2 above. The above argument holds even if v outside is not a leaf vertex but is grounded. Thus (25) holds.
• Not grounded and has no directed path to v inside : First, we show there is neither any destruction of existing SCCs, nor creation of any new one. This follows because no cycle is created by the addition of the arc (v inside → v outside ), since v outside has no directed path back to v inside . Next, we need to consider if the appended arc may change some SCCs from leaf to non-leaf or vice versa. For the leaf SCC V S , the appended arc makes it become non-leaf, since this is an outgoing arc which does not form a cycle. For SCCs other than V S , the appended arc is an incoming arc, which will not change the SCCs' being leaf or non-leaf. So, we have (25) for this particular case.
• Not grounded and has a directed path to v inside : Here, the appended arc creates a cycle between v inside (in V S ) and v outside (outside V S ). This causes the original leaf SCC V S to become a larger SCC by assimilating some external nodes (that include v outside ). If we could show that none of the assimilated external nodes belongs to any leaf SCC (meaning that no other leaf SCC is affected by this appending step), then clearly either (24) or (25) holds depending on whether the enlarged SCC have outgoing arcs or not. Indeed none of the assimilated external nodes belong to any leaf SCC, because they each have a directed path to v inside . Thus, we conclude the argument for this case. To show (26), we follow the same line of argument as in the proof of Proposition 1. Let (G, U) and (G , U ) denote the graphs before and after the appending step, respectively. First, adding an arc increases the decoding requirements and result in˜ * (G , U ) ≥˜ * (G, U). On the other hand, Lemma 12 says that receiver v outside can decode all messages of V inside S using any index code for (G, U). This implies that any index code for (G, U) is also an index code for (G , U ). So,˜ * (G, U) is achievable for the problem instance (G , U ). So, (26) must hold.
Finally, as v inside already has at least one outgoing arc before the appending step (since it belongs to an SCC), this step does not change the number of vertices with outgoing arcs. We have (27).

APPENDIX D PROOF OF LEMMA 10
From Sections VI-D1 to VI-D3 and Appendices B to C, we see that, besides the leaf SCC being operated on, all other leaf SCCs remain as leaf SCCs. In addition, pruning and appending neither remove nor add any edge in U, and thus all other message-connected and message-disconnected leaf SCCs remain as leaf SCCs of the same type. For a degenerated leaf SCC not being operated on, it remains degenerated because we have the following after the pruning/appending operation on another leaf SCC: • There is no addition or removal of edges in U, and so V inside S remains unchanged, and the leaf SCC will neither become message-connected nor message-disconnected.
• The number of non-leaf vertices in V outside S can only decrease, as all leaf vertices remain leaf vertices, and some non-leaf vertices may become leaf vertices (we might add more leaf vertices into V outside S , see the argument below); and • Each neighbor of V inside S can still be in V outside S or be a predecessor of some vertex in V outside S . This is because appending other leaf SCCs will not change the neighbor set. If we prune some other leaf SCC by removing all outgoing arcs from a vertex, say v, that happens to be in the path from a neighbor of V inside S to V outside S , we just add v (which has been made a leaf vertex) to V outside S .

APPENDIX E A MULTI-SENDER INSTANCE CANNOT BE TRIVIALLY SPLIT INTO MULTIPLE SINGLE-SENDER INSTANCES
Consider the following information-flow graph: 1 3 2 4 Suppose that there are two senders, one having (x 1 , x 2 ), and the other (x 3 , x 4 ). We have a message-disconnected leaf SCC, and the optimal index-codelength is˜ * = 4.
Consider splitting this index-coding instance into two singlesender instances according to the senders' messages. The first instance consists of the first sender with messages (x 1 , x 2 ). Since there are only two messages, we cannot have vertices 3 and 4 in the information-flow graph, i.e., we have 1 2 This first single-sender instance has an optimal index codelength of * = 1, and an optimal code of x 1 ⊕ x 2 .
The second instance can be similarly defined: a sender having (x 3 , x 4 ) and the information-flow graph is as follows: 3 4 This second single-sender instance has an optimal index codelength of * = 1, and an optimal code of x 3 ⊕ x 4 . Combining these two instances gives a total codelength of * = 2 with a code (x 1 ⊕ x 2 , x 3 ⊕ x 4 ). However, this is not an index code for the original instance as receiver 2 cannot decode x 4 . In conclusion, we cannot trivially split a multisender uniprior instance into separate single-sender uniprior instances. Having said that, one can do so for unicast instances.