Expander chunked codes

Chunked codes are efficient random linear network coding (RLNC) schemes with low computational cost, where the input packets are encoded into small chunks (i.e., subsets of the coded packets). During the network transmission, RLNC is performed within each chunk. In this paper, we first introduce a simple transfer matrix model to characterize the transmission of chunks and derive some basic properties of the model to facilitate the performance analysis. We then focus on the design of overlapped chunked codes, a class of chunked codes whose chunks are non-disjoint subsets of input packets, which are of special interest since they can be encoded with negligible computational cost and in a causal fashion. We propose expander chunked (EC) codes, the first class of overlapped chunked codes that have an analyzable performance, where the construction of the chunks makes use of regular graphs. Numerical and simulation results show that in some practical settings, EC codes can achieve rates within 91 to 97 % of the optimum and outperform the state-of-the-art overlapped chunked codes significantly.

distributed fashion, and is shown to be asymptotically capacity-achieving for networks with packet loss in a wide range of scenarios [5]- [7].
A major issue in applying RLNC is the high computational cost. Consider the dissemination of k input packets, each consisting of L symbols from a finite field. For encoding, RLNC requires O(kL) finite field operations to generate a coded packet, and for decoding, a destination node has to invert a k × k dense matrix and use the inverse to recover the whole input packets, which costs O(k 2 + kL) finite field operations per packet if Gaussian elimination is employed. For a file of thousands of packets (roughly several megabytes), the computational cost of both encoding and decoding would become too high to be implementable in real systems.
As a variation of RLNCs, chunked (network) codes have been proposed to bring down the computational costs [8], [9]. In a chunked code, the input packets are encoded into multiple small chunks (also called generations, classes,  [10]. Moreover, to recover the transfer matrices of chunks at the destination nodes, a coding vector of m symbols is usually included in all the packets [3]. When packet length L has an upper bound (for example, network protocols usually have an Maximum Transmission Unit (MTU) of several thousand bytes), using large m will reduce the transmission efficiency.
These considerations suggest that the chunk size should be a small, fixed constant rather than an increasing function of the number of input packets or the network size. In this paper, we focus on the design and analysis of efficient chunked codes with a fixed chunk size.

A. Related Works
The chunked codes discussed in the literature are in one of the following categories.

1) Disjoint chunks:
The simplest way is to use disjoint subsets of the input packets as chunks. This is the first class of chunked codes discussed for network coding [8], and is used in some experiments of linear network coding [11], [12]. To decode, the transfer matrices of all chunks must have rank m. So the decoding complexity is O(m 2 + Lm) finite field operations per packet.
But it is not always a simple task to guarantee the success of decoding with high probability. Take the line network in Fig. 1 as an example. In the presence of link-by-link feedbacks, each node, except for the destination node, can keep transmitting the coded packets of a chunk until the node in the next hop receives m linearly independent packets of the chunk. When feedbacks are not available (e.g., in satellite and deep-space communications) or have a high cost (e.g., in wireless networks), a random scheme has been studied in [9], where a node randomly selects a chunk to transmit at each time slot. But this random scheme has poor performance for small chunk sizes [13], [14]. May  2) Chunks with overlapping: To resolve the issue of disjoint chunks, chunks with overlapping have been discussed by several groups independently [13]- [15]. Such a chunked code is also called an overlapped chunked code. Since different chunks share some packets, the decoding of one chunk can help the decoding of the other chunks. So it is not necessary to guarantee that the transfer matrices of all chunks have rank m. Compared with disjoint chunks, overlapped chunked codes do not incur extra encoding cost, while increase the decoding cost slightly.
It is shown via simulations that overlapped chunked codes have much better performance than disjoint chunks [13], [14]. However, the existing designs of chunks with overlapping are mostly based on heuristics. The random annex codes proposed by Li et al. [15] demonstrate better performance in simulation than the overlapped chunked codes in [13], [14], but only heuristic analysis of the design is provided.

3) Chunks with sparse generator matrices:
In addition to using subsets of the input packets, chunks can also be generated using coding. BATS code [16], [17] is the first class of chunked codes that uses coded chunks. Each chunk in a BATS code is generated by a small subset of the input packets, where the cardinality of the subset is called the degree of the chunk. BATS code can be regarded as a matrix generalization of fountain codes [18], [19], and preserves salient features of fountain codes, in particular, their ratelessness and low encoding/decoding complexity.
Both asymptotic and finite-length analysis of BATS codes have been obtained [17], [20], [21]. Numerical results show that BATS codes approach closely the optimal performance.
For BATS codes, the encoding complexity is O(LmΨ) per chunk and the decoding complexity is O(m 3 + LmΨ) per chunk, whereΨ is the average degree of the chunks and is usually several times of m. Compared with the fountain codes of the same block length, BATS codes have higher computational cost since the encoding of a batch uses a dense generator matrix and decoding of a batch solves a dense linear system of equations. 1 : Gamma codes proposed by Mahdaviani et al. [23] also use coded chunks, where chunks satisfy some parity-check constraints, similar to these of LDPC codes. The parity-check constraints can be applied on the whole chunk as in the Gamma codes discussed in [23], and can also be applied on the individual packets in chunks as in the improved Gamma codes proposed recently in [24]. The improved Gamma codes show better performance than the original Gamma codes and the overlapped chunked codes [13]- [15]. Gamma codes are analyzed for sufficiently large field sizes with the assumption that the rank of a randomly selected chunk transfer matrix follows a truncated binomial distribution. The encoding/decoding cost of Gamma codes is similar to that of BATS codes, but higher than that of overlapped chunked codes.

B. Paper Results Summary
In this paper, we propose a new class of overlapped chunked codes, called expander chunked (EC) codes. This is the first class of chunked codes with overlapping that has analyzable performance. In EC codes, overlapped chunks are formed using expander graphs, which have been extensively used in coding design (see [25], [26]). Benefiting from the expansion property of expander graphs, throughout the decoding process, those decoded chunks can always provide substantial help for decoding the remaining chunks. We characterize the achievable rates of EC codes with precoding by conducting a tree-based analysis and some expander arguments.
We evaluate numerically the asymptotic achievable rates of EC codes for line networks with length up to 10 and a range of erasure rates, and compare the achievable rates with those of BATS codes and the improved Gamma codes. The numerical results show that the achievable rates of EC codes are lower than those of BATS codes and Gamma codes, but the achievable rates of EC codes are within 10.2 percent from an upper bound of the achievable rates for all chunked codes. Simulation results show that EC codes achieve higher rates than the existing overlapped chunked codes.
The rest of the paper is organized as follows. Section II formally defines chunked codes and the model used for analyzing the performance. The description and analysis of EC codes are given in Section III and Section IV, respectively. Section V presents the performance evaluation, and finally, Section VI has the concluding remarks.

II. CHUNKED CODES
Consider transmitting a set of k input packets b 1 , b 2 , . . . , b k from a source node to a destination node over an erasure network. Each input packet composes of L symbols from the finite field F q with size q, and is regarded as a column vector in F L q henceforth.
Definition 1 (Chunked code). A chunk is a set of packets each of which is a linear combination of the input packets, and a chunked code is a collection of chunks. A chunk is said to be genuine if all the packets in the chunk are input packets, and a chunked code is said to be genuine if all the chunks in the code are genuine.
In other words, a chunked code is a linear block code with symbols in the codewords separated into chunks.
We assume that all the chunks in a chunked code have the same cardinality m, which is called the chunk size. We study the design and analysis of chunked codes with a fixed chunk size which does not change with the number of input packets k. The chunk size is related to the encoding/decoding computational complexities and the storage requirement of the intermediate network nodes. We will discuss how to choose a proper value of the chunk size using an example in Section V.

A. Transmission of Chunks
Now we describe a chunk transmission model through a network employing linear network coding. Consider a chunked code with n chunks, say C 1 , C 2 , . . . , C n . With this chunked code, each transmitted packet in the network is a linear combination of packets in C j = {u j i , i = 1, . . . , m}. For convenience, we refer to a packet with chunk ID j as a j-packet. When there is a chance of transmission, a network node, including the source node, performs the following operations: 1) Select a chunk C j according to certain chunk selection strategy from all the chunks the node has.
2) Generate a new j-packet by randomly combining all the existing j-packets at the node with random coefficients.
Specifically, denote the existing j-packets as (j, c i , b i ), i = 1, . . . , h, and the new j-packet as (j, c, b). We where φ i , i = 1, 2, . . . , h are chosen from F q independently and uniformly at random.
Note that in (1), we only need to combine the linearly independent j-packets. So the computational cost of generating a coded packet is O(mL) finite field operations. The coding vector overhead is also determined by the chunk size m. Though from the computation complexity and the coding vector overhead point of view, we should choose m as small as possible, we will show that a fairly large m is also necessary to gain the benefit of network coding.
We abuse the notation by treating C j as a matrix formed by juxtaposing the packets in chunk C j . Let Y j be the matrix whose columns correspond to all the j-packets, excluding the chunk ID and the coding vector part, received by the destination node. Since all the operations at network nodes are linear, where T j is an m × N random matrix called the (chunk) transfer matrix of C j . Here N is an integer that bounds the number of received packets of a chunk at the destination node. Chunk transfer matrices are known by the destination node from the coding vectors included in the received packets. According to the random linear network coding scheme we describe, we can further write where S j is an m × M j random matrix corresponding to the linear combination performed by the source node, and H j is an M j × N random matrix corresponding to the linear operations performed by intermediate nodes as well as the random packet erasures over the network links. Here M j is also random and for a given value of M j , S j is a total random matrix (i.e., every entry of S j is chosen from F q uniformly and independently at random).
The transmission model defined in (2) does not depend on the chunk selection scheme. We study how to design a good chunked code under the assumption that T j , j = 1, 2, . . . , n are independent and identically distributed (i.i.d), and for each chunk C j , H j and S j are independent conditioning on M j and rk(S j ). We will discuss an example of the chunk transmission scheme in Section V.

B. Decoding
The destination node tries to decode the input packets using Y j and the knowledge of T j for j = 1, 2, . . . , n. The decoding is equivalent to solving the local linear systems Y j = C j T j , j = 1, 2, . . . , n. These local linear systems for chunks give a global linear system of equations on the k input packets, but solving the global linear system without considering the chunk structure usually has high computational cost. Therefore, we study the decoding algorithms based on the local linear systems. If rk(T j ) = m, then the linear system of chunk C j can be solved by Gaussian elimination and all the packets in chunk C j are decoded.
But it is possible that for some chunks C j , rk(T j ) < m. If there exist overlapping and/or parity check constraints between different chunks, then the decoded chunks can help the decoding of undecoded chunks. We will discuss such belief propagation (BP) decoding algorithms in details for the chunked codes that we will study in the following sections. Use genuine chunked codes as an example. When a chunk C j is successfully decoded, the linear systems associated with chunks C i , C i ∩ C j = ∅, are updated by substituting the value of packets in C i ∩ C j and reducing i.e., Pr{rk(T j = i} = t i for any i = 0, 1, . . . , m. The following property is used in the analysis of decoding algorithms.

Lemma 1. Let D be a fixed matrix with m rows and rk(D) = w. Then,
We use the following metric to evaluate the efficiency of a chunked code.
Definition 2 (Achievable rate). Let Φ k be a chunked code with k input packets and n k chunks. A rate λ is said to be (1 − k −c )-achievable (or just achievable for brevity) by Φ k if λ ≤ k mn k and the destination node can recover all the k input packets with probability at least 1 − k −c for some constant c > 0. A rate λ is said to be achievable by a sequence of chunked codes {Φ k } k∈N if λ is achievable by every Φ k for some fixed c > 0 with k sufficiently large.
A natural upper bound on the achievable rates of chunked codes is established as follows. Let

Proposition 2. The achievable rate of any sequence of chunked codes is upper bounded byt/m.
Proof: Assume that λ = (1 + ǫ)t/m, ǫ > 0 is achievable by a sequence of chunked codes. Note that in the decoding of a chunked code, only received packets of a chunk with linearly independent coding vectors are useful. May 22, 2014 DRAFT Thus, the error probability of decoding a chunked code is lower bounded by where the last equality follows from the Chernoff bound. Therefore, P e → 1 as n → ∞, which is a contradiction to the assumption that λ is achievable.

C. Precoding
Definition 3. The degree of a chunk is the cardinality of the minimum subset of the input packets that can generate the chunk; a packet in the minimum subset is said to be involved in the chunk.

Proposition 3.
For any sequence of chunked codes {Ψ k } k∈N that achieves rate λ > 0, the average degree of chunks is lower bounded by c ′ log k when k is sufficiently large, where c ′ > 0 does not depend on k.
Proof: Suppose that Ψ k has n k chunks. Let a i , i = 1, 2, . . . , k, be the number of chunks that involve packet whered is the average degree of all chunks. Hence, there must exist j such that a j ≤ n k kd .
Let E denote the event that b j cannot be decoded and A j be the set of indices such that C i involves b j . Notice that E holds as long as rk(T j ) = 0 for all i ∈ A j . Since the transfer matrices T i are independent, we have When k is sufficiently large, Ψ k can achieve rate λ ≤ k mn k . Therefore, for some constant c > 0. Note that T j = S j H j and S j has a nonzero probability to be the zero matrix. So t 0 > 0.
Thus, for sufficiently large k,d The proof is completed by noting that m, c and t 0 do not depend on k.
Since the average degree of chunks in a genuine chunked code is at most m and hence is independent of k, Proposition 3 implies that any sequence of genuine chunked codes cannot achieve a positive rate. Further, the bound on the average degree implies that the per packet encoding complexity is at least c ′ log(k). To resolve the above issues, we use the technique of precoding that has been used in Raptor codes [19]. Maymounkov et al. [9] have considered precodes for disjoint chunks. We study the achievable rates using successive decoding of the chunked code and the precode, in which we first decode the chunk code to recover a fraction of the intermediate input packets and then decode the precode to recover the original input packets. A joint decoding of the precode and the chunked code can be applied, which potentially achieves better performance. Nevertheless, the successive decoding performance gives a lower bound on the joint decoding performance that is independent of the choice of the precode, as long as the precode meets the above requirement.
Consider a family of chunked codes {Φ k } k∈N (without precoding) such that for a constant 0 < η ≤ 1 and every Φ k with k sufficiently large, ηk input packets can be recovered with probability at least 1 − k −c for some fixed c > 0. We can see that the rate is achievable by {Φ k } k∈N using the precodes described above with precode rate η, where n k is the number of chunks in Φ k and ǫ > 0 is an arbitrarily small positive constant.

III. EXPANDER CHUNKED CODES
The simplest genuine chunked code with precoding is the one where the chunks are disjoint subsets of the intermediate input packets, which is called the Non-Overlapped Genuine (NOG) chunked code. Since the decoding of chunks of a NOG chunked code cannot help each other, the achievable rate of NOG chunked code with successive decoding is t m , the probability that a chunk transfer matrix has rank m (see Appendix B for a formal argument).
We introduce a family of genuine chunked codes, named Expander Chunked (EC) codes, which use expander graphs to generate chunks with overlapping, and show that this family of chunked codes can achieve much higher rates with successive decoding than NOG chunked codes when chunk transfer matrices have rank less than m with high probability.

A. Code Description
For overlapped genuine chunked codes (i.e., some input packets appear in more than one chunks), one desired property is that those decoded chunks can provide substantial help for decoding the remaining chunks via the overlapped packets throughout the iterative decoding process. In the following, we will show that such property  , and E(S, V \ S) is the set of edges between S and its complement. Readers are referred to [29] for more information about expander graphs. Here without loss of generality, we assume that n = k m−d/2 is an integer and dn is even. Otherwise, we could introduce a few blank packets as input packets. We will refer to G as the generator graph of the EC code, and explain how to construct G later.
2) Associate each edge e ∈ E with a distinct packet, and denote the packet by b e . Associate the rest k − nd/2 = (m − d)n packets evenly with the n nodes in V , and denote the set of packets associated with node v by B v .
3) Form n chunks {C j , 1 ≤ j ≤ n}, where C j consists of all the packets in B j and the packets associated with edges incident to node j, i.e., C j = B j ∪ {b e : e is incident to node j}.
We can check that the number of packets in each chunk is m since |B j | = m − d and each node is incident to d edges. An EC code example is illustrated in Fig. 2.
If we ignore the indices of the packets, the chunks formed by the above scheme is solely determined by the generator graph G. Also, due to the one-to-one correspondence between chunks and nodes in G, they are used interchangeably henceforth. Moreover, every chunk overlaps with d chunks, each on a distinct packet. Therefore, when decoding, a chunk can enjoy different help from d different neighboring chunks. Moreover, since G has a constant expansion ratio, any set of decoded chunks include a large number (equal to the size of edges between the set and its complement and thus proportional to the number of decoded or undecoded chunks) of packets that appear in remaining chunks, thus guaranteeing the desired property. May 22, 2014 DRAFT Now we specify how to construct the expander graph G. We take the random approach by regarding G as a random d-regular graph 2 , since a random d-regular graph is an expander graph with high probability, easier to analyze and has better expansion ratio than expander graphs constructed by existing deterministic approaches such as the Margulis method [31], zig-zag product [32], etc. Also, since d is a constant, a random d-regular graph G can be generated in expected time O(nd 3 ) = O(n) by applying the algorithm proposed by McKay and Wormald [33].
Noting that the number of edges in the graph is dn/2 = O(n), the time cost of step 2) is O(n). Besides, step 3) requires O(n) time. Therefore, the whole EC code construction can be finished in expected time O(n).

B. Achievable Rates
We study the following BP decoding of an EC code. We say a chunk is decodable if its degree is equal to the rank of the chunk transfer matrix. In the first round, all decodable chunks are decoded by solving the linear system of equations given in (2). After a chunk is decoded, all the m packets in the chunk are decoded. In each of the following rounds, an undecoded chunk can potentially be decoded with the help of the decoded chunks. For each decoded packet in the last round, the degree of the undecoded chunk that includes this packet, if exists, is reduced by one, and the corresponding row of the transfer matrix of the chunk is also removed. Since the degrees of some chunks are reduced, some undecodable chunks may become decodable. We then decode all the decodable chunks.
We now characterize the achievable rates of of the above BP decoding algorithm. To state the main result, we need to introduce some notations. For any 3 ≤ d ≤ m and w ≤ d, define a function α d (y) over the interval [0, 1] where β w is defined in Lemma 1. Note that and We can further check that α d (y) is monotonically increasing in y (see Appendix C). With function α d (y) and its functional powers, we introduce a sequence where α i+1 d (0) = α d (α i d (0)) for all i > 0. This sequence is well-defined since the range of α d is in [0, 1] (cf. (5)). Further, since α d (0) > 0 and α d (y) is monotonically increasing, we can check inductively that the sequence in (6) is also monotonically increasing. Since the sequence is upper bounded, it must converge. Denote We further define Theorem 4. A sequence of precoded EC codes with the degree of generator graphs to be d can achieve a rate at least κ d /m − ǫ, where ǫ > 0 is an arbitrarily small constant.

IV. ANALYSIS OF EC CODES
In this section, we provide an analysis of the achievable rates of EC codes and prove Theorem 4. The analysis consists of two main parts. In the first part, we show that a random regular graph has the locally tree-like property and then bound the number of chunks that can be decoded based on a tree-based analysis. Note that for EC codes, the number of decodable chunks does not immediately give us the number of decodable packets due to the overlapping among chunks. So in the second part, we utilize the expansion property of random regular graphs to give a lower bound on the number of decodable packets, which finally leads to Theorem 4.

A. Tree Analysis
Now we characterize the number of decodable chunks. We start by introducing some notations. In the following, we set l = 1 3 log d−1 n .
Our tree analysis is based on the locally tree-like property of a random regular graph G, i.e., almost all the nodes in G have their l-neighborhoods to be trees.

Lemma 5. For a random d-regular graph G with n nodes, let T be the number of nodes with their l-neighborhoods
to be trees. Then, for any constant ǫ > 0, Proof: Let X r be the number of cycles of length r in G. One important fact is that a node whose l-neighborhood is not a tree must belong to a cycle with length less than or equal to 2l + 1. Therefore, Since (d − 1) 2l+1 = o(n), it was shown in [34] that, for any 3 ≤ r ≤ 2l + 1, Taking expectation on both sides of (7) and substituting (8) gives

Finally, by Markov's inequality, we get
Pr{T Now we show the probability that a node v is l-decodable given that G l (v) is a tree. Note that the tree-based analysis of EC codes is not the same as the and-or-tree analysis used for LT and LDPC codes.

Lemma 6.
Let v ∈ V be a node such that G l (v) is a tree. Then the probability that v is l-decodable is at least (1 − ǫ)τ d for any constant ǫ > 0 and sufficiently large n.
Proof: Consider the tree G l (v) rooted at v. Clearly, the root v has d children nodes and all other internal nodes have d − 1 children nodes. Let h i be the probability that a node u at level i (here we assume that the node v is at level l and the leaves are at level 0) is decodable when the decoding process of u is restricted within the subtree of G l (v) rooted at u. In the following, we calculate h i in a bottom-up fashion.
For a leaf node u, since it cannot get any help from other chunks in G l (v), For any node u at level i, 1 ≤ i ≤ l − 1, suppose that w out of d − 1 children nodes of node u have been decoded.
Note that each of these children nodes overlaps with node u at a distinct packet. Therefore, when decoding u, these w overlapping packets provide additional w linearly independent coding vectors beyond T u . According to Lemma 1, the probability that u can be decoded is β w . Since the local decoding processes of all the children nodes May 22, 2014 DRAFT of node u are mutually independent, we have

By induction, we have
Similarly, since the node v in the level l has d children nodes, When n → ∞, which implies l → ∞, α l d (0) → α * d . Therefore, h l → τ d as α d+1 (y) is continuous. Hence, for any constant ǫ > 0, for n sufficiently large.
Lemma 6 together with Lemma 5 bounds the expected number of l-decodable nodes. In the following, we show that the actual number of l-decodable nodes is sharply concentrated to its expectation.
Proof: Let Z be the number of l-decodable nodes in G. According to Lemma 6, since ǫ/2 > 0, for sufficiently large n, Now consider a standard vertex exposure martingale on G as follows. Let and for i = 1, 2, . . . , n, let The sequence Z 0 , Z 1 , . . . , Z n gives a standard Doob martingale [35]. Recall that the l-decoding process of each node v is restricted within the l-neighborhood G l (v). Therefore, the exposure on T v can affect the expected number of l-decodable nodes by at most the number of nodes in G l (v). More precisely, for each 1 ≤ i ≤ n, Applying the Azuma-Hoeffding Inequality [35], we have Combining (10), (11), (12) and noting that Z n = Z, we get as desired.

B. Expander Arguments
Now we utilize the expansion property of random regular graphs to derive a lower bound on the number of decodable packets when a certain number of chunks are decodable.
We first introduce some known results about the expansion property of a random regular graph, which is usually characterized by the graph spectrum of the random regular graph, i.e., the set of eigenvalues of its adjacency matrix.

Proposition 8.
The following hold for a random d-regular graph with n nodes: 2) For any ǫ > 0, there exists some constant c > 0, such that Pr{λ max ≤ 2

3) For any subset S of δn nodes, the number of edges between nodes in S is at most dn
Proof: The claims in 1), 2) and 3) are proved in [36], [37] and [38], respectively.

Lemma 9.
Suppose that δ-fraction of chunks in a random generator graph G are decodable. Then, for any constant ǫ > 0, the number of decodable packets is at least Proof: Let S ⊆ V be the set of decodable chunks in G, and Λ be the number of decodable packets. As each packet appearing in two chunks corresponds to one edge in G, the number Λ is equal to m|S| minus the number of edges between nodes in S. Therefore, for any constant ǫ > 0 and conditioning on that λ max ≤ 2 √ d − 1 + ǫ, where the first step follows Proposition 8.
By noting that the event λ max ≤ 2 √ d − 1 + ǫ holds with probability 1 − O (n −c ) for some constant c > 0 according to Proposition 8, the proof is accomplished.
Now we are ready to prove Theorem 4.
Proof of Theorem 4: Consider a sequence of EC codes indexed by the number of input packets k with the same degree of generator graphs to be d. Let ∆ be the number of input packets that can be decoded. Then, by combining Lemma 5, Lemma 7 and Lemma 9, we have that with probability at least 1 − k −c for some constant c > 0, any constant ǫ > 0 arbitrarily small and k sufficiently large. Therefore, any rate less than κ d /m is achievable by the sequence of EC codes.

V. PERFORMANCE EVALUATION
where the first node v 0 is the source node and the last node v Λ is the destination node. Each network link is a packet erasure channel and can transmit one packet in a time slot. We assume that all network links have the same erasure probability ǫ, and the network transmission is instantaneous. An example of line network of length 3 is given in Fig. 1.
In the following, we first introduce a chunked code scheme in line networks with erasures. We then evaluate the performance of EC codes with this scheme for line networks. The scheme for line networks can be extended to directed acyclic unicast networks and some multicast networks using the same technique as in [39]. We will not repeat the extensions here.

A. Scheme for Line Networks
The chunked code scheme introduced here is defined for general chunked codes. The only parameter of this scheme is a real numberM . We say a random variable X follows the rounding distribution with parameter x, The source node encodes n chunks C 1 , C 2 , . . . , C n . The chunks are transmitted according to the order of their indices. For chunk C j , the number of packets transmitted by the source node is M j . Here we assume that M j , j = 1, . . . , n are i.i.d. and follow the distribution RD(M ). The M j packets of chunk C j are transmitted in M j consecutive time slots. After that, the source node continues to transmit C j+1 . When the transmission of all chunks is accomplished, the source node sends an ending signal to node v 1 , which is assumed to be reliable. May 22, 2014 DRAFT All the intermediate nodes apply the same operation. We discuss the operation at node v i , 0 < i < Λ as an example. Node v i transmits the chunks according to the order of they are received, and when the transmission of all chunks is accomplished, it sends an ending signal to node v i+1 which is assumed to be reliable. For each chunk C j , v i starts to transmit C j if both of the following two conditions are satisfied: 1) Node v i has received m linearly independent j-packets or has received at least one j ′ -packet for some j ′ > j; 2) Node v i has completed the transmission of chunk C j−1 .
The first chunk and the last chunk are special. Chunk C 1 can be transmitted when only the first condition is satisfied, and chunk C n can be transmitted after the ending signal from v i−1 is received and the second condition is satisfied.
j denote the number of linearly independent j-packets received by node v i . We know that R where S (i−1) and E (i) are random matrices defined as follows. The number of columns of S (i−1) as well as the order of E (i) , denoted by random variable M (i−1) , has the distribution RD rk(T (i−1) )M E(rk(T (i−1) )) .
Given the event M (i−1) = w, S (i−1) is a totally random matrix and E (i) has the same distribution as E w . Then we have that the transfer matrix of a chunk has the same distribution as T (k) and for i = 1, . . . , Λ, redefine Given the event rk(T (i−1) ) = b, random variable M (i−1) follows the distribution Thus for a = 0, 1, . . . , m and b ≥ a, Then, the distribution of R (i) can be calculated using the following recursive formula

B. Numerical Evaluation and Simulation
To evaluate the efficiency of chunked codes for the line network, we want to see how many packets are transmitted on average by one use of the network, 3  improved Gamma codes have asymptotic achievable rates characterized. 4 The results are plotted in Fig. 4. From this figure, we observe that EC codes can achieve a rate close to that of BATS codes and improved Gamma codes, which is fair since EC codes have much simpler and regular structure than the other two codes. The chunk degree of EC codes is less than 1/3 of the average chunk degree of BATS codes, which means the decoding computational cost of EC codes is roughly 1/3 of that of BATS codes. Further, the achievable rate of EC codes is within 10.2 percent of the upper bound. We can similarly evaluate the performance for other values of m to determine a choice of the chunk size.
Last, we compare EC codes with two overlapped chunked codes: the chunked codes that include chunks with a head-to-tail type of overlapping (called H2T chunked codes) [14] and random annex codes [15]. Since we do not have the analytical results to calculate the achievable rates of these two codes, we perform a simulation in the line network with length four and ǫ = 0.2 to compare the performance. For each code, we perform 10000 runs of the simulation. The number of chunks in each code is set to be 500, and the parameters involved in H2T chunked codes and random annex codes are chosen such that the average number of decodable input packets is maximized.
The empirical cumulative distribution function of the number of decodable input packets for each code is plotted in Fig. 5. From this figure, we can see that EC codes outperform H2T chunked codes significantly and is clearly better than random annex codes. 4 In [24], the (improved) Gamma codes are analyzed only for sufficiently large field sizes with the assumption that the rank of a randomly selected chunk transfer matrix follows a truncated binomial distribution. It is possible to analyze the improved Gamma codes for the transmisson model defined in this paper (ref. [40]).

VI. CONCLUDING REMARKS
In this paper we studied the performance of overlapped chunked codes with constant chunk sizes. We proposed and analyzed EC codes, a novel class of expander graph based chunked codes, which outperform state-of-the-art overlapped chunked codes. Compared with coded chunked codes, in many cases EC codes can achieve a rate very close to that of BATS codes and Gamma codes, but EC codes have lower encoding/decoding complexity. Thus, where the first step follows since A is invertible.
For any s and r such that s ≥ r, define S s,r to be the set of all m × s matrices with rank r. Since S j is totally random given M j = s and A is invertible, for any S ∈ S s,r , Using the assumption that S j and T j are independent conditioning on M j and rk(S j ), we have The proof is completed by combining the above equality with (14).
Using the above lemma, we can now prove Lemma 1. As there are m i i-dimensional subspaces of F m q , and q (m−i)(m−w) w m−i i-dimensional subspaces of F m q such that dim( T j ∩ D ) = r + w − i (ref. [41], [42]), by Lemma 10, we have Proof: Consider an NOG chunked code C 1 , C 2 , . . . , C n with k input packets, where n = k/m. Let I j be an indicator random variable such that I j = 1 if C j can be decoded and I j = 0 otherwise. When rk(T j ) = m, C j can be decoded. This implies that E[I j ] = Pr{I j = 1} ≥ Pr{rk(T j ) = m} = t m .
Let D = n j=1 I j be the number of chunks that can be decoded. Due to the linearity of expectation, Since I 1 , . . . , I n are mutually independent, we can apply the Chernoff bound to obtain that, for any constant 0 < ǫ < 1, for constant c > 0 and any k sufficiently large. In other words, at least (1 − ǫ)t m k input packets can be recovered with probability at least 1 − k −c . Now it is straightforward to see that any rate less than tmk mn = t m can be achieved by a sequence of precoded NOG chunked codes.
Note that the achievable rates characterized in Proposition 11 can be achieved by a sequence of precoded NOG chunked codes with fixed rate precodes. In typical scenarios of network coding, the packets of a chunk of an NOG chunked code are usually decoded together by solving a linear system of equations. Under this condition, the characterization in Proposition 11 is tight. This is formally established in the following result.

Proposition 12.
Assume that for an NOG chunked code, the packets of a chunk can either all be decoded or none.
Then any rate larger than t m is not achievable by precoded NOG chunked codes using successive decoding.
Proof: Assume that rate λ = (1 + ǫ)t m , ǫ > 0 is achievable by precoded NOG chunked codes using successive decoding. Consider that the precode encodes k ′ input packets to k precoded packets, which are further encoded to n = k/m chunks by an NOG chunked code. Then for every sufficiently large k, at least k ′ precoded packets can be recovered by decoding the chunks with probability at least 1 − k −c . In other words, where D is defined as in the proof of Theorem 11. Since λ ≤ k ′ mn , this implies On the other hand, by the Chernoff bound, we have for sufficiently large k, which is a contradiction to (15). Therefore, a rate larger than t m cannot be achieved by precoded NOG chunked codes using successive decoding.
The second term of the right hand in (17) can be transformed into Therefore, since β w ≥ β w−1 . The proof is accomplished.

ACKNOWLEDGMENT
We would like to thank Prof. Raymond W. Yeung for many useful discussions.