Packet Output and Input Configuration in a Multicasting Session Using Network Coding

Abstract

This work proposes a model to solve the problem of Network Coding over a one-session multicast network. The model is based on a system of restrictions that defines the packet flows received in the sink nodes as functions of the outgoing flows from the source node. A multicast network graph is used to derive a directed labeled line graph (DLLG). The successive powers of the DLLG adjacency matrix to the convergence in the null matrix permits the construction of the jump matrix Source-Sinks. In its reduced form, this shows the dependency of the incoming flows in the sink nodes as a function of the outgoing flows in the source node. The emerging packets for each outgoing link from the source node are marked with a tag that is a linear combination of variables that corresponds to powers of two. Restrictions are built based on the dependence of the outgoing and incoming flows and the packet tags as variables. The linear independence of the incoming flows to the sink nodes is mandatory. The method is novel because the solution is independent of the Galois field size where the packet contents are defined.

1. Introduction

 Traditional routing mechanisms allow intermediate nodes to execute storage-and-forward actions; therefore, each packet (the element of the vector space \(\mathbb{F}^{n}_{q}\), where \(\mathbb{F}_{q}\) is the finite field with q elements and q = 2) is a copy of a previously received packet in an input link to the node. In multicast systems, intermediate nodes can receive packets over input links, besides they can be duplicated and forwarded to multiple output links.

 However, this mechanism is prone to traffic congestion. However, Network Coding (NC) [1–3] allows each router, which acts as a node in the network, to carry out the mixing of its incoming packets by computing a linear combination, not only in the source and sinks nodes, but also in the intermediate nodes. Fig. 1 shows a node (router) with three incoming packet flows and two outgoing flows, which are a linear combination of the incomers. When NC is used in transmissions, especially multicast transmissions, packets can be forwarded, mixed (coded) at intermediate nodes, and decoded to obtain the original packets at the sink nodes [4]. Therefore, NC theory shows that the transmission of information in a multicast system can be improved and surpass the paradigm of routing and data replication.

 

Fig. 1. Computing outgoing packets from incoming packets

 According to [5], "Network Coding means that bits in information flows do not have to be delivered as a commodity; these can be mixed as desired, as long as the receiving computers have received enough evidence or clues to reconstruct the original packets of the sending computer."

 Fig. 2 (in [4] and [6]) shows a network consisting of directed links with the same capacity of B bps. Without intermediate routing nodes, the source computers s₁ and s₂ send a packet stream to the receiving computers t₂ and t₁, respectively. In turn, the source computer s₁ attempts to send packets to computer t₁ , and computer s₂ attempts to send packets to computer t₂. Observation shows that the outgoing packets of 𝑠𝑠1 reach t₁ only through the path s₁ → 1 → 3 → 4 → 6 → t₁, and the outgoing packets of s₂ reach t₂ only through the path s₂ → 2 → 3 → 4 → 5 → t₂. It is clear that the link (3,4) is shared and acts as a bottleneck for simultaneous transmission.

 

Fig. 2. Two unicast sessions in contention for the link (3,4) [4]

 If the nodes that make up the Fig. 2 network only route the information they receive, then link (3,4) must be shared between the two unicast sessions, which only allows the following set of transmission rates {(r₁, r₂)|r₁, r₂ ≥ 0, r₁ + r₂ ≤ B} and these are interpreted graphically in Fig. 3(a) [7]. It is not possible for any of the unicast sessions to establish a communication stream with a rate greater than B. However, if the network nodes can implement NC, specifically on node 3 of the shared link (3,4), then both sessions can reliably communicate at rate B, which permits the set of transmission rates {(r₁, r₂)|0 ≤ r₁ ≤ B, 0 ≤ r₂ ≤ B } as shown in Fig. 3(b) [7]. Therefore, the region of Fig. 3(b) comprises all of the possible flow rates, and this is called the capacity region for these sessions [4] [7]. For both unicast sessions, rate B is achieved by mixing the information flows in node 3 using the XOR operation. By applying the XOR operation again, the original flows are obtained in nodes 5 and 6. In Fig. 2, the blue and purple line links carry the original information flows, whereas the red links carry the mixed flow.

 

Fig. 3. The ranges of reachable transfer rates for (a) traditional routing and (b) routing with NC [4]

 According to [8], the current communications networks share the same fundamental operating principle. Regardless of whether packets are sent over the Internet or signals on a telephone network, the information is transported like vehicles traveling along a highway. Just as cars share the road, data flows share the resources of the network. However, the information packets themselves, like individual cars, are separate.

 Currently, communication networks treat data packets as unmodifiable units; that is, data packets produced at the source are routed through the network until they reach a sink. In this process, each packet remains intact. The NC paradigm, which was initially proposed in [1], breaks with this previous assumption. It suggests that instead of merely forwarding data, nodes can combine several incoming packets into one or more outgoing packets, which makes it unnecessary to deliver the actual packets produced by the source node to the sink nodes. The sink nodes can obtain the original packets through a process of decoding the received packets.

 This work proposes a system of linear equations (constraints) whose solution determines the ordering of the r-packets over the vector space \(\mathbb{F}_{q}^{n}\) in the outgoing links from the source node, where 𝑟𝑟 corresponds to the maximum flow of a multicast session. This ordering ensures that the packets are correctly delivered to the sink nodes. Packets can be sent from the source node in the original format (single packets) or in linear combinations of single packets (combined packets). Also, combined packets can be created through inner nodes of the network. These packets, which are defined over \(\mathbb{F}_{q}^{n}\), arrive at the sink nodes where they must be linearly independent so that the system has a solution.

 The importance of this work is that the most relevant constraints derived from the solution define each incoming flow in each sink as a linear combination of some of the outgoing flows in the source node. The resulting linear combinations are expressed in terms of the codes representing the packets. The packets are tagged as variables based on a code system over the vector space \(\mathbb{F}_{2}^{r}\), where the constraints are set with coefficients over \(\mathbb{F}_{2}\).

 This work can neither be extended directly to a network with losses or errors in the packets, nor when there are broken links. However, for future studies with transport protocols and error control, along with routing protocols for updating the routes, they can use the results achieved from this study for the most efficient delivery of the packets. Currently, large Internet providers include redundancy at three levels to mitigate these problems. The first is at the router level, which can have more than one high capacity processor installed. The second level is the connection of more than one link between a pair of routers. Finally, there is the redundancy of destination routers from an origin with a high traffic load. An example of a redundancy application is the Virtual Router Redundancy Protocol (VRRP) [29].

 Knowledge of the topology is a prerequisite for the objective proposed in this work. An algorithm must run to determine the paths that lead from the source node to the set of sink nodes before the application of the proposed model. The algorithm would demand a high computational cost when determining the topology that favors the use of Network Coding due to the unknown and complex nature of the global network through which the multicast routing would be conducted. The determination of the multicast network has become one of the most complex tasks for the construction of a solution with Network Coding [19]. However, after the algorithm defines the topology, the overhead would be subject to the convergence times involved in the entry and exit of the nodes, and the breakdown and recovery of the links. These times are within a few seconds with current processor technologies.

 Two topologies with coding nodes were utilized to show the application of the explained model. The topologies do not have a specific name. The main advantage of these topologies is that they show the simultaneous sending of packets from the source node, the construction of linear combinations in the coding nodes, and the decoding of packets in the sinks. The main disadvantage is that in the case of implementation, there should be a synchronization of the packets sent at the exit and arrival to the routers to achieve reception and decoding in the sinks.

 This paper is organized as follows. Section 2 is a review of the studies related to the proposal. Section 3 explains the principles of construction of the network model. A detailed explanation of the proposed problem is included in Section 4. Section 5 describes the representation of the network model in matrices and the classification of the links. Section 6 discusses the construction of the solution bases and the algorithms that support it. Section 7 shows how to obtain the constraints of the model from the exposed bases. Section 8 provides examples of the implementation of this proposal. Finally, the conclusion and recommendation of future work are presented in Section 9.

2. Related Work

 The initial theoretical work in NC was developed by Ahlswede et al. [1] and was modeled with a directed graph G = (V, E) with links without noise and with capacities of a symbol of a field \(\mathbb{F}_{q}\) per unit of time. They showed that a source node, s ∈ V, can send the same information to a set of sink nodes, \(T=\left\{t_{1}, t_{2}, \ldots, t_{d}\right\} \subset V\), where s ∉ T, at a maximum data rate r.

 Ahlswede et al. demonstrated that the problem with a multicast session is an underutilization of resources by restricting the use of the network nodes to only the execution of the routing function. Their work also demonstrated that the multicast capability, r(s, T), or the maximum rate at which a source node can transmit common information to a set of sink nodes, is determined by the lower value of the maximum flows from the source node 𝑠𝑠 to each of the sink nodes t ∈ T. That is:

\(r(s, T)=\underset{t \in T}{min} \operatorname{Max} F {low}(s, t).\)       (1)

 The above result is known as information flow theorem, which is considered a generalization of the classic max-flow-min-cut theorem for commodity flow [9] and was tested independently by Elías et al. [10] and Ford and Fullkerson [11] [12] in 1956.

 NC demonstrates that it is possible to increase performance and gain an advantage over traditional routing mechanisms. Also, whereas routing mechanisms cannot achieve multicast capacity, it can be achieved through NC.

 Li et al. [3] demonstrated that linear coding functions in the inner nodes are enough to achieve the maximum multicast capacity and thus define Linear Network Coding (LNC). LNC considers messages as packets consisting of elements over a finite field \(\mathbb{F}_{q}\) [13], which can be represented by a binary vector of length log2(q) bits [6]. The coding function that generates a message emerging from a node is a simple linear combination of incoming messages to the node over the finite field \(\mathbb{F}_{q}\). Likewise, linear operations on incoming information permit decoding in the sink nodes.

 Koetter and Médard [2] [14] showed that linear solutions exist for solvable multicast networks with an alphabet of some finite field whose size is a power of two and is as large as r|T|. Also, they demonstrated how to find the coefficients of linear coding and decoding functions by searching for the values of the variables of a non-zero polynomial. However, for the solution of the multicast problem, the structure they proposed produces a polynomial time algorithm. Authors in [15–17] showed how to find the linear coding and decoding coefficients for a multicast session through an algorithm that runs in polynomial time over a finite field of maximum size |T|.

 The authors of [18] proposed a significant improvement to the performance of end-to-end multicast transmission through the replication and forwarding of data by overlay nodes instead of sending them through end systems. In their work, they determined that overlay nodes have the total capacity to encode and decode data at the message level using LNC. They also proposed a distributed algorithm to construct a directed acyclic graph (DAG) corresponding to the multicast network in which NC is applied. This algorithm duplicates end-to-end performance in several cases.

 The NC-based multicast routing algorithm proposed in [19] aims to find the path-clusters between the source node and each sink. The path-cluster corresponds to the r paths of disjoint links between the source node and each sink in a multicast system. Through the labeling algorithm, it is possible to find the maximum flow r between any two nodes in a network [20] [21] and also obtain the r disjoint paths for each sink node in a multicast session.

 In [22], a routing and coding scheme is presented to achieve maximum packet transport in a multicast session by determining and combining the paths of the multiple maximum flows through overlapping links. The authors propose that only the links and nodes in the combined maximum flows will be used to construct the coding and routing scheme.

 Based on the advantages of the shortest path Dijkstra algorithm and NC, the proposed routing algorithm [23] has a higher performance and load balancing capacity than the shortest path distribution tree algorithm.

3. Principles of Model-Building

3.1 Communications Network Model

 This work studies multicast transmission (wired or wireless) with the purpose of sending the same information from a source node to all sink nodes at the same data rate (bandwidth). This communications network is modeled with a directed, acyclic and lossless (entirely reliable) link graph G = (V, E), where V represents the set of nodes (routing only or routing/coding), and E is the set of directed links that join the nodes. Let i,j ∈ \(\mathbb{N}\), then it is established that ∀e ∈ E , it is represented as the ordered pair e = (i,j), where i,j ∈ V are ordered topologically, and this indicates that i < j The flow of information goes from node i to node j, and delays in transmission are not considered. The origin and the destination node of a link e = (i,j) is denoted by o(e) = i and d(e) = j, respectively. In simple multicast communication, the sender or source node s ∈ V can transmit the same information to a set of sink nodes T⊆V, where s ∉ T.

 Γ_I(t) is defined in [2] as the set of links that enter node i ∈ V, and Γ_O(i) as the set of links that originate in i. Formally, this is written as:

\(\Gamma_{I}(i)=\{e \in E | d(e)=i\}.\)       (2)

\(\Gamma_{O}(i)=\{e \in E | o(e)=i\}.\)       (3)

 𝛿_I(i) is also defined as the degree or number of links entering i, whereas 𝛿_𝑂(i) is the degree or number of links that emerge from i: formally, 𝛿_𝐼(i) = |Γ_I(i)| and 𝛿O(i) = |Γ_O(i)|.

 Each link e ∈ E is associated with a non-negative number C(e), which is called the capacity of e. A node i can send information through a link e = (i,j), at a maximum rate of C(e) bits per unit of time. The bit stream (called a random process in [2] [24]) is transmitted through link e and is denoted by f_e o f_ij. Also, at node i, the flows f_e′ enter through each e′ ∈ Γ_I(i). In general, the stream of the bits f_e, transmitted through link e = (i,j) ∈ Γ_O(I) will be a function of all of the flows f_e′ , assuming that e′ ∈ Γ_I(i).

3.2 Maximum Transmission Rate

 The model aims to send the same information from the source node to each sink node at the maximum possible data rate. We let r(s, T) (or simply r) denote the rate at which the same information can reliably be transmitted to each sink node t ∈ T. It is observed that the maximum transmission rate or bandwidth, r(s, T), has as an upper bound related to the minimum of the maximum flows between s and each t ∈ T, which indicates that 𝑟𝑟(𝑠𝑠, 𝑇𝑇) ≤ 𝑚𝑚𝑚𝑚𝑚𝑚𝑡𝑡∈𝑇𝑇𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀(𝑠𝑠,𝑡𝑡). Likewise, in [25], the MaxFlow-MinCut theorem proved that the minimum cut, 𝑠𝑠 -𝑡𝑡, is equal to the maximum flow for the unicast case, i.e., 𝑟𝑟(𝑠𝑠, 𝑇𝑇) ≤ 𝑚𝑚𝑚𝑚𝑚𝑚𝑡𝑡∈𝑇𝑇𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀(𝑠𝑠,𝑡𝑡). This maximum transmission rate is only achievable in a network where multicast communication is performed using NC, and this is demonstrated by [1].

 In the proposed model, the maximum transmission rate, 𝑟𝑟 = 𝑚𝑚𝑚𝑚𝑚𝑚𝑡𝑡∈𝑇𝑇𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀𝑀(𝑠𝑠,𝑡𝑡) , between source node 𝑠𝑠 and set 𝑇𝑇 of the sink nodes in a multicast session corresponds to the maximum number of packets generated in the source node 𝑠𝑠, which is the same number of packets delivered in each of the nodes 𝑡𝑡 ∈ 𝑇𝑇. The generated and delivered 𝑟𝑟 packets are 𝑙𝑙 symbols length (bits that are over the field 𝔽𝔽2). Therefore, the unit of measure of 𝑟𝑟 in bits (symbols) per unit of time (as mentioned in earlier sections) is no longer considered.

3.3 Symbols, Codes and Fields

 The directed links of 𝐺𝐺 can reliably carry packet 𝑝𝑝, where 𝑝𝑝 is a vector of length 𝑙𝑙 bits set over the finite field 𝔽𝔽𝑞𝑞, 𝑞𝑞 = 2𝑚𝑚, and 𝑚𝑚 is the number of bits per symbol over the finite field. The number 𝐿𝐿 of symbols of length 𝑚𝑚 bits constituting the packet is determined by:

\(L=\left\lceil\frac{l}{\log _{2}\left|\mathbb{F}_{q}\right|}\right\rceil=\left\lceil\frac{l}{\log _{2}\left(2^{m}\right)}\right\rceil=\left\lceil \frac{l}{m}\right\rceil.\)       (4)

 For example, given a network with a packet 𝑝𝑝 of 12 bits long and 3 bits per symbol (they are over the field 𝔽𝔽23), the following values are deduced:

 The length of packet 𝑙𝑙 is 12 bits. The number of 𝑚𝑚 bits per symbol over the finite field 𝔽𝔽𝑞𝑞 is 3 bits per symbol. The number of 3-bit symbols over the finite field 𝔽𝔽𝑞𝑞 is �𝔽𝔽𝑞𝑞� = 23 = 8 3-bit symbols. The number of symbols in the packet is 𝐿𝐿 = � 12 𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏 3 𝑏𝑏𝑏𝑏𝑏𝑏𝑏𝑏/𝑠𝑠𝑠𝑠𝑚𝑚𝑏𝑏𝑏𝑏𝑏𝑏� = 4 symbols over the field 𝔽𝔽𝑞𝑞. It is observed that the packet has a length of 12 bits, 𝑝𝑝 ∈ 𝔽𝔽𝑞𝑞 4, with 𝑞𝑞 = 23. All of the packets generated and transmitted through the network links will be over the vector space 𝔽𝔽23 4 , and a total of �𝔽𝔽23 4 � different packets can be generated.

 A sample of these packets is shown below with the 3-bit symbols grouped in parentheses:

\(\begin{aligned} &p_{1}=[(001)(010)(100)(110)]\\ &p_{2}=[(010)(000)(110)(110)]\\ &p_{3}=[(100)(110)(001)(101)] \end{aligned}\)

3.4 Vector Spaces and Packets

 Packets are classified as simple or combined. Simple packets are the original packets generated by the client’s computer placed before the source node and obtained (through linear decoding) in the |𝑇𝑇| sink nodes, whereas combined packets are the result of linear combinations that occur along the multicast transmission from the source node 𝑠𝑠 to any of the sink nodes in 𝑇𝑇.

 The source node 𝑠𝑠 receives the 𝑟𝑟 simple packets that determine the maximum flow of the multicast session from the sending computer, and each content of a simple packet 𝑝𝑝 is defined over 𝔽𝔽2 𝑙𝑙 . For example, if 𝑙𝑙 = 7, the packets generated and received by 𝑠𝑠 belong to the vector space 𝔽𝔽2 7 and are 7 bits long.

 In the model, each packet corresponds to an information unit constituted by 𝑙𝑙 bits and each network link is defined by a bandwidth equal to the information unit. All of the links in the model have the same capacity.

 Let 𝑐𝑐(𝑝𝑝) be the code of packet 𝑝𝑝; the simple and combined 𝑟𝑟 packets built along the transmission to the 𝑇𝑇-nodes are represented (or tagged) by codes belonging to the set:

\(\wp=\left\{c(p) | c(p) \in\left[1: 2^{r}-1\right]\right\}.\)       (5)

 The codes of simple packets shape the ℘𝑢𝑢 set, such that ℘𝑢𝑢 ⊂ ℘, where:

\(\wp_{u}=\left\{c(p) | c(p)=u_{i}=\left[0^{i-1}, 1,0^{r-i}\right], i=1, \ldots, r\right\}.\)       (6)

 The vector 𝑢𝑢𝑖𝑖 is the 𝑖𝑖 𝑡𝑡ℎ vector of the canonical basis of 𝔽𝔽2 𝑟𝑟. The number of codes in ℘ that can be handled in a multicast session of maximum flow 𝑟𝑟 is |℘| = 2𝑟𝑟 − 1, and the number of codes corresponding to the simple packets is |℘𝑢𝑢| = 𝑟𝑟.

 In addition, the simple packet codes (or tags) are also represented by mnemonics corresponding to an alphabet Σ = {𝐴𝐴1,𝐴𝐴2, … , 𝐴𝐴𝑟𝑟} and are related following the topological ordering of the alphabet symbols as specified in the following bijective function:

\(\begin{aligned} &g: \wp_{u} \longmapsto \Sigma\\ &g\left(u_{i}\right)=A_{i} \end{aligned}\)       (7)

 From function 𝑔𝑔, it follows that Σ = {𝐴𝐴𝑖𝑖|𝐴𝐴𝑖𝑖 = 𝑔𝑔(𝑢𝑢𝑖𝑖), 𝑢𝑢𝑖𝑖 ∈ ℘𝑢𝑢}, and |Σ| = 𝑟𝑟.

 For example, if 𝑟𝑟 = 3, the sets ℘,℘𝑢𝑢 and Σ are: ℘ = {001,010,011,100,101,110,111}, ℘𝑢𝑢 = {001,010,100} and Σ = {𝐴𝐴, 𝐵𝐵, 𝐶𝐶}, where 𝑔𝑔(001) = 𝐴𝐴 , 𝑔𝑔(010) = 𝐵𝐵, and 𝑔𝑔(100) = 𝐶𝐶. 

 From the above, the codes representing the 𝑟𝑟 packets that can be transmitted from the source node 𝑠𝑠, in a multicast session are nonzero elements of the vector space 𝔽𝔽2 𝑟𝑟. That is, packets are distinguished by their representative codes and not by their contents. Likewise, if the mnemonics or codes that identify two or more packets are different, then so are their contents.

 In each coding/routing node, the outgoing packet corresponds to a linear combination of the incoming packets and uses as global coding coefficients [24], the symbols (bits) with a value of 1 belong to the field 𝔽𝔽2. This linear combination translates into a bit-by-bit sum of the component bits of the packets that enter the node.

 For example, in Fig. 4, each packet 𝑝𝑝𝑖𝑖, arriving at coding node 𝑐𝑐 has length 𝑙𝑙, which is 𝑝𝑝𝑖𝑖 ∈ 𝔽𝔽2 𝑙𝑙 and each 𝑎𝑎𝑖𝑖, 𝑏𝑏𝑖𝑖 ∈ 𝔽𝔽2 . In node 𝑐𝑐 , the linear combination for each output link is established. During the transmission and propagation process, the new packet 𝑝𝑝1 + 𝑝𝑝2 and length 𝑙𝑙 is forwarded bit-by-bit from node 𝑐𝑐 to each of the adjacent nodes, which are connected to the output links. It is important to highlight that because of this approach, the 𝑙𝑙-bitwise sums are calculated between the two packets to determine the combined packet.

4. Proposed Problem

4.1 Statement of the Problem

 The NC problem (and determining a solution) on a multicast session has been approached in different ways according to [2] [16] [17]. However, in all cases, it has been revised from the contents of the messages or packets, which limits the solution to the size of the field to which the contents belong.

Fig. 4. The bit-by-bit linear combination in the packets

 A multicast session for a communications network is configured with a source node 𝑠𝑠, a set of sink nodes 𝑇𝑇, a unit capacity of information per link of length 𝑙𝑙 bits and a maximum flow 𝑟𝑟 for each node in 𝑇𝑇 as shown in Fig. 5.

 The goal is to determine the tag or code in ℘ that names the packets for each of the 𝜅𝜅 output links 𝑒𝑒1, 𝑒𝑒2, … , 𝑒𝑒𝜅𝜅 that emerge from the source node 𝑠𝑠. This process guarantees the reception of independent linear combinations into the sink nodes to retrieve the codes in ℘𝑢𝑢 of the original simple 𝑟𝑟-packets. The packets are sent through the inner links and the nodes of 𝐺𝐺 and are tagged with codes in ℘ or specified as linear combinations of the mnemonics in Σ.

 This goal includes accommodating (on each outgoing link 𝑒𝑒1, 𝑒𝑒2, … , 𝑒𝑒𝜅𝜅 from 𝑠𝑠) the best tag combination (vectors 𝑢𝑢𝑖𝑖 or their linear combinations) in ℘ to transfer across the network internally and obtain the tags of the original packets for each node in 𝑇𝑇 and through the solution of a system of linearly independent constraints. That is, the linear combinations generated in 𝑟𝑟 paths that reach each node in 𝑇𝑇 from 𝑠𝑠 must be linearly independent.

 The solution is established without considering the size of the field to which the contents of the packets belong. That is, regardless of its length in bits, only the size of the tag or code of each packet generated in the source node will be considered.

 In Fig. 5 and for each outgoing link from 𝑠𝑠, packets emerge and are generated with either 𝐴𝐴𝑖𝑖 = 𝑔𝑔(𝑢𝑢𝑖𝑖) or linear combinations of codes representing the tags in ℘𝑢𝑢. A packet stream must enter each sink node, where the codes representing the stream are in ℘ and must be linearly independent. Incoming codes are the result of linear combinations during transmission through the inner nodes.

4.2 Upper Bound of the Number of Outputs

 It is important to note that the solution is not unique to any 𝐺𝐺-graph representing a multicast session. We let 𝜎𝜎 denote the number of possible combinations of packets sent through the outgoing links from 𝑠𝑠. The solutions are specified in two terms: for simple packets and for combined packets.

 The maximum number of combinations of simple packets emerging from node 𝑠𝑠 through the outgoing links is:

\(\sigma=r^{K}.\)       (8)

Fig. 5. A general vision of the problem

 If it is considered that node (router) 𝑠𝑠 can generate linear combinations from the simple packets entering it, then it would be possible to obtain up to a maximum limit of combinations:

\(\sigma=\left(\sum_{i=1}^{r}\left(\begin{array}{l} r \\ i \end{array}\right)\right)^{\kappa}=\left(2^{r}-1\right)^{\kappa}.\)       (9)

 It is important to specify that not all combinations are valid solutions to the multicast problem proposed because they would have no solution in the incoming links to the sink nodes.

5. Representation of the Network Model

5.1 Network Adjacency Matrix

 An adjacency matrix represents the communication network for a multicast session with the different routes from 𝑠𝑠 to the sinks in 𝑇𝑇 = {𝑡𝑡1,𝑡𝑡2, … ,𝑡𝑡𝑑𝑑}. Each cell in the matrix represents the capacity of each of the links that make up the network after obtaining the disjoint paths from 𝑠𝑠 to each sink. This matrix is called 𝐶𝐶 and is |𝑉𝑉| × |𝑉𝑉| in size, where:

\(C(i, j)=\left\{\begin{array}{ll} 0, & (i, j) \notin E \\ 1, & (i, j) \in E \end{array}\right..\)       (10)

 As previously specified, in link 𝑒𝑒 = (𝑖𝑖,𝑗𝑗), 𝑖𝑖,𝑗𝑗 ∈ 𝑉𝑉, 𝑖𝑖 < 𝑗𝑗, a topological ordering of the links in 𝐸𝐸 is reached.

5.2 Classification of the Links

 A link 𝑒𝑒 ∈ 𝐸𝐸 can be classified according to whether 𝑜𝑜(𝑒𝑒) is the source node or not and if 𝑑𝑑(𝑒𝑒) is in 𝑇𝑇 or not, in any of the following types:

\( {Type}(e)=\left\{\begin{array}{ll} 0, & o(e) \neq s, d(e) \notin T \\ 1, & o(e)=s, d(e) \notin T \\ 2, & o(e) \neq s, d(e) \in T \\ 3, & o(e)=s, d(e) \in T. \end{array}\right.\)       (11)

 Type 0 corresponds to the inner links, which originate from a node other than 𝑠𝑠 and whose destinations do not belong to set 𝑇𝑇. Type 1 links are called outgoing links since they originate from 𝑠𝑠 and end in any node that does not belong to 𝑇𝑇.

 Type 2 links are called incoming links since they originate from a node other than 𝑠𝑠 and end in any node belonging to 𝑇𝑇. Finally, type 3 links are called outgoing-incoming links since they send packets directly from 𝑠𝑠 to a sink in 𝑇𝑇 without passing through inner links.

 A limited number of packets arrive at each sink node as determined by the upper boundary of the flow of the multicast network. Since the capacity of each link 𝑒𝑒 ∈ 𝐸𝐸, 𝐶𝐶(𝑒𝑒) = 1, the number of incoming links that carry the flow to each sink node is equal to

\(r(s, T) \leq \underset{t \in T}{min}{Min}{Cut}(s, t)=\underset{t \in T}{min}{Max} \operatorname{Flow}(s, t).\)       (12)

 The set of outgoing links is noted as 𝑆𝑆, which corresponds to the following definition:

\(S=\{e \in E | o(e)=s, d(e) \notin T\}.\)       (13)

 The set of incoming links is noted as 𝐿𝐿 and corresponds to the following definition:

\(L=\{e \in E | o(e) \neq s, d(e) \in T\}.\)       (14)

 The set of outgoing-incoming links is noted as 𝐾𝐾, which is defined as:

\(K=\{e \in E | o(e)=s, d(e) \in T\}.\)       (15)

 From section 4.1, (13), and (15) it was determined that the number of links emerging from 𝑠𝑠 is |𝑆𝑆 ∪ 𝐾𝐾| = |𝑆𝑆| + |𝐾𝐾| = 𝜅𝜅; and from (14) and (15) it was established that |𝐿𝐿 ∪ 𝐾𝐾| = |𝐿𝐿| + |𝐾𝐾| = 𝑟𝑟|𝑇𝑇|.

5.3 Links Table

 The links table is constructed as shown in Table 1 from the adjacency matrix 𝐶𝐶, which represents 𝐺𝐺 and the classification of the links.

Table 1. Links table format

 If 𝐶𝐶(𝑖𝑖,𝑗𝑗) = 1, link 𝑒𝑒𝑙𝑙 = (𝑖𝑖,𝑗𝑗) with index 𝑙𝑙 contains 𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂𝑂(𝑙𝑙) = 𝑖𝑖 (the same as 𝑜𝑜(𝑙𝑙) = 𝑖𝑖) and 𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷𝐷(𝑙𝑙) = 𝑗𝑗 (the same as 𝑑𝑑(𝑙𝑙) = 𝑗𝑗). 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑙𝑙) is specified according to what was previously defined.

 Let 𝜆𝜆 be the number of entries in the links table or the number of links in the graph, which is determined by the number of cells in 𝐶𝐶 whose value is 1 and is defined as:

\(\lambda=\sum_{i=1}^{|V|} \sum_{j=1}^{|V|} C(i, j).\)       (16)

6. Solution Bases

6.1 Directed Labeled Line Graph and Hop Matrix

 The directed labeled line graph (DLLG) [2] [14] derived from 𝐺𝐺 = (𝑉𝑉, 𝐸𝐸) is 𝔊𝔊 = (𝒱𝒱, ℰ), which is constructed from the capacity matrix 𝐶𝐶 with the following rules:

 1) Each node 𝑣𝑣 ∈ 𝒱𝒱, corresponds to a directed link 𝑒𝑒 = (𝑖𝑖,𝑗��) ∈ 𝐸𝐸, then 𝒱𝒱 = 𝐸𝐸.

 2) Each link 𝑒𝑒′ ∈ ℰ, is defined as 𝑒𝑒′ = (𝑒𝑒1, 𝑒𝑒2), where 𝑒𝑒1, 𝑒𝑒2 ∈ 𝐸𝐸 and 𝑑𝑑(𝑒𝑒1) = 𝑜𝑜(𝑒𝑒2) and therefore ℰ = {(𝑒𝑒1, 𝑒𝑒2) ∈ 𝐸𝐸2|𝑑𝑑(𝑒𝑒1) = 𝑜𝑜(𝑒𝑒2)}.

 3) Adjacency matrix 𝐹𝐹 = �𝐹𝐹(𝑘𝑘, 𝑙𝑙)� 𝑘𝑘=1,𝑙𝑙=1 |𝒱𝒱| is built for graph 𝔊𝔊 , where any link 𝑒𝑒′ = (𝑒𝑒1, 𝑒𝑒2) ∈ ℰ is labeled according to (17)

\(F\left(e_{1}, e_{2}\right)=\left\{\begin{array}{ll} 1, & d\left(e_{1}\right)=o\left(e_{2}\right) \\ 0, & \text { otherwise } \end{array}\right..\)       (17)

 The matrix of hop 𝐹𝐹, which results from the above rules, has the following characteristics:

 1) It is an upper diagonal matrix with zeros on the main diagonal because it is constructed from a graph whose nodes and links are labeled in topological order.

 2) Given the above, it is a nilpotent matrix [26], which indicates ∃𝑛𝑛 ∈ ℕ such that 𝐹𝐹𝑛𝑛 = 0.

 3) Given the nilpotency of 𝐹𝐹, the 𝐹𝐹ℎ = �𝐹𝐹ℎ(𝑘𝑘, 𝑙𝑙)� 𝑘𝑘=1,𝑙𝑙=1 |𝒱𝒱| matrix is generated, where each 𝐹𝐹ℎ(𝑘𝑘, 𝑙𝑙) , 1 ≤ ℎ ≤ 𝑛𝑛, is interpreted according to its value as:

\(F^{h}(k, l)=\left\{\begin{array}{ll} i, & { i \ paths \ from \ link \ } k { \ to \ link \ l \ in \ h \ hops.} \\ 0, & { \ no \ path \ from \ link \ k \ to \ link \ l \ in \ h \ hops.} \end{array}\right.\)       (18)

6.2 Source-Sinks Hop Matrix

 From the matrix of a hop and its properties and using Algorithm 1, the Source-Sinks Hop matrix 𝑄𝑄 is constructed and has a size of (|𝑆𝑆| + |𝐾𝐾|) × |𝐸𝐸|.

Algorithm 1: Construction of the Source-Sinks Hop matrix

Input: \(\boldsymbol{F}, \boldsymbol{S} \cup \boldsymbol{K}, \boldsymbol{E}\) Output: Source-Sinks Hop matrix \(\boldsymbol Q\)

//The rows of \(Q\) are constituted by links \(k\) such that \(k \in S \cup K\). //The columns of \(Q\) are constituted by every link \(l \in E\) (including the inner or type 0 links, which are not necessary for the final model).   1 Initialize \(Q\) with \(Q(k,l)=0\), (\(\forall k \in S \cup K,(\forall l \in E)\))   2 For each \(F^{h},(1 \leq h //Actualization of \(Q\)   3   For each \(k \in S \cup K\)   4     For each \(l \in E\)   5       If \(F^{h}(k, l)>=1\) and \(Type (l)=2\)   6         \(Q(k, l)+=F^{h}(k, l) / / I n c r e a s e s ~ b y \ F^{h}(k, l) \ { each \ time }\)   7       End If   8     End For   9   End For 10 End For 11 Return \(\boldsymbol Q\)

 

 In conclusion, each 𝑄𝑄(𝑘𝑘, 𝑙𝑙) ≠ 0 represents the number of times that the outgoing link flow 𝑘𝑘 (𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑘𝑘) = 1), contributes in a linear combination to the calculation of the incoming link flow 𝑙𝑙 (𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑙𝑙) = 2). That is, if 𝑓𝑓𝑘𝑘 corresponds to the outgoing flow from 𝑠𝑠 and is transmitted through the outgoing link 𝑘𝑘 , then 𝑄𝑄(𝑘𝑘, 𝑙𝑙) ∗ 𝑓𝑓𝑘𝑘 is the flow that will transit in a linear combination through the incoming link 𝑙𝑙 to the sink node 𝑑𝑑(𝑙𝑙). Thus, 𝑓𝑓𝑘𝑘 will contribute 𝑄𝑄(𝑘𝑘, 𝑙𝑙) times to the linear combination of the incoming flow through the incoming link 𝑙𝑙 to the sink node 𝑑𝑑(𝑙𝑙). Actually, the flow from which the outgoing link 𝑘𝑘 will contribute is 𝑓𝑓𝑘𝑘 if 𝑄𝑄(𝑘𝑘, 𝑙𝑙) is an odd integer and it is zero, otherwise.

 Let ℒ = {𝑙𝑙 ∈ 𝐸𝐸 | 𝑑𝑑(𝑙𝑙) ∉ 𝑇𝑇} and the links with destinations not in 𝑇𝑇, i.e., 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑙𝑙) = 0 or 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑙𝑙) = 1. From this definition and previous definitions, the following theorems are established:

 Theorem 1: Let 𝒍𝒍 ∈ 𝑳𝑳, then 𝑸𝑸𝑻𝑻(𝒍𝒍) ≠ 𝟎𝟎 (𝑸𝑸𝑻𝑻(𝒍𝒍) denotes the 𝒍𝒍 𝒕𝒕𝒕𝒕 column of matrix 𝑸𝑸 and 𝑸𝑸𝑻𝑻 is the transpose of 𝑸𝑸).

 Proof: If 𝑙𝑙 ∈ 𝐿𝐿, by definition of set 𝐿𝐿, then 𝑑𝑑(𝑙𝑙) ∈ 𝑇𝑇. Besides, 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑙𝑙) = 2 and so for each iteration of Algorithm 1 until 𝐹𝐹𝑛𝑛 = 0 is reached, when there are ℎ hops from 𝑘𝑘 to 𝑙𝑙; that is, when 𝐹𝐹ℎ(𝑘𝑘, 𝑙𝑙) = 𝑖𝑖, the increase of cell 𝑄𝑄(𝑘𝑘, 𝑙𝑙) is achieved, and this prevents 𝑄𝑄𝑇𝑇(𝑙𝑙) = 0

 Theorem 2: Let 𝒍𝒍 ∈ 𝓛𝓛, then 𝑸𝑸𝑻𝑻(𝒍𝒍) = 𝟎𝟎.

 Proof: If 𝑙𝑙 ∈ ℒ, then by definition of set ℒ, 𝑑𝑑(𝑙𝑙) ∉ 𝑇𝑇. Besides, 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑙𝑙) ≠ 2 and 𝑇𝑇𝑇𝑇𝑇𝑇𝑇𝑇(𝑙𝑙) ≠ 3, and so for each iteration of Algorithm 1 until 𝐹𝐹𝑛𝑛 = 0 is reached, the increase in cell 𝑄𝑄(𝑘𝑘, 𝑙𝑙) will not be achieved and this will lead to 𝑄𝑄𝑇𝑇(𝑙𝑙) = 0 

 Theorem 3: If 𝒍𝒍 is a link where 𝑻𝑻𝑻𝑻𝑻𝑻𝑻𝑻(𝒍𝒍) = 𝟑𝟑, then 𝑸𝑸𝑻𝑻(𝒍𝒍) = 𝟎𝟎.

 Proof: If 𝑙𝑙 is a type 3 link, then 𝑙𝑙 ∈ 𝐾𝐾 and by definition 𝑜𝑜(𝑙𝑙) = 𝑠𝑠 and 𝑑𝑑(𝑙𝑙) = 𝑡𝑡 ∈ 𝑇𝑇. This indicates that 𝑙𝑙 is a direct link from 𝑠𝑠 to 𝑡𝑡 with no intermediate nodes. Thus, there are no links before or after 𝑙𝑙, and consequently, 𝑙𝑙 is an incoming link with no hops where each iteration of Algorithm 1 produces 𝐹𝐹ℎ(𝑘𝑘, 𝑙𝑙) = 0, ∀𝑘𝑘 ∈ 𝑆𝑆 ∪ 𝐾𝐾 and results in 𝑄𝑄𝑇𝑇(𝑙𝑙) = 0 

 𝑄𝑄 contains |ℒ| columns in 0, and these are called non-sink columns, which do not show any relationship between an outgoing link and an incoming link or specifically between node 𝑠𝑠 and some 𝑡𝑡 ∈ 𝑇𝑇. Furthermore, they fulfill Theorem 2.

 The rest will be called sink columns, which are constituted by columns 𝑙𝑙 whose 𝑑𝑑(𝑙𝑙) ∈ 𝑇𝑇, i.e., the columns that fulfill Theorem 1 or Theorem 3.

 The running time of Algorithm 1 is 𝑂𝑂(𝑛𝑛|𝑆𝑆 ∪ 𝐾𝐾||𝐸𝐸|) = 𝑂𝑂(𝑛𝑛𝑛𝑛|𝐸𝐸|).

6.3 Reduced Source-Sinks Hop Matrix

 In the Source-Sinks Hop matrix, the |ℒ| columns in 0 (non-sink columns) that correspond with links 𝑙𝑙 ′ ∈ 𝐸𝐸 such that 𝑑𝑑(𝑙𝑙 ′ ) ∉ 𝑇𝑇, are eliminated to get the Reduced Source-Sinks Hop matrix, i.e., only the columns corresponding to type 2 or type 3 links are kept. 𝑄𝑄𝑟𝑟 denotes the Reduced Source-Sinks Hop matrix, and (|𝑆𝑆| + |𝐾𝐾|) × (|𝐿𝐿| + |𝐾𝐾|) = 𝜅𝜅𝜅𝜅|𝑇𝑇| is its dimension. Algorithm 2 shows the process of reducing the Source-Sinks Hop matrix.

Algorithm 2: Reduced Source-Sinks Hop Matrix

Input: \(\boldsymbol{Q}, \boldsymbol{L }\cup \boldsymbol K, \boldsymbol S \cup \boldsymbol K\) Output: \(\boldsymbol{Q}_{\boldsymbol{r}}\)

1. Initialize \(Q_{r}\) with \(Q_{r}(k, l)=0\), (\(\forall k \in S \cup K,(\forall l \in L \cup K)\)) 2. For each link \(l \in L \cup K\) 3.   \(Q_{r}^{T}(l)=Q^{T}(l)\) 4. End For 5. Return \(Q_{r}\)

 

 The running time of Algorithm 2 is 𝑂𝑂(|𝑆𝑆 ∪ 𝐾𝐾||𝐿𝐿 ∪ 𝐾𝐾|) = 𝑂𝑂(𝜅𝜅𝜅𝜅|𝑇𝑇|).

7. Construction of constraints

7.1 Principles of the Proposed Method

 The proposed model starts with the graph 𝐺𝐺 = (𝑉𝑉, 𝐸𝐸), which represents a multicast network of a single source node 𝑠𝑠, a set of sink nodes 𝑇𝑇, maximum flow 𝑟𝑟, and capacity 𝐶𝐶(𝑒𝑒) = 1 for each link 𝑒𝑒 ∈ 𝐸𝐸. The goal was to construct a system of linear constraints formed by variables that represent the outgoing, incoming, and outgoing-incoming packet flows, where each flow is represented by the code associated with the packet (a simple or a combined packet) that can travel through the link. The model is based on three principles:

7.1.1 Definition of Constraints in the Source Node

 In node 𝑠𝑠, different packets are created and distinguished with a tag length of 𝑟𝑟-bits and with 𝐴𝐴𝑖𝑖 = 𝑔𝑔(𝑢𝑢𝑖𝑖), where 𝑢𝑢𝑖𝑖 is the vector defined in section 3.4. From this node, |𝑆𝑆| + |𝐾𝐾| links (outgoing and outgoing-incoming) emerge and allow the establishment of 𝑟𝑟 possible output packets for each of these links. Then, it is deduced that the following simple flows (a single packet per outgoing or outgoing-incoming link) can be obtained according to the relationship:

\(f_{e}=A_{1}\left|A_{2}\right| \ldots | A_{r}, \forall e \in S \cup K.\)       (19)

 It is possible that for each link ∈ 𝑆𝑆 ∪ 𝐾𝐾 , there is a linear combination (combined packets) of simple packets emerging, tagged with some 𝑢𝑢𝑖𝑖, and generating a packet 𝑝𝑝𝑒𝑒 tagged 𝑐𝑐(𝑝𝑝𝑒𝑒) ∈ ℘ that is stored in the combined flow 𝑓𝑓𝑒𝑒:

\(f_{e}=\sum_{u_{i} \in \wp} u_{i}=\sum_{u_{i} \in \wp, g\left(u_{i}\right)=A_{i}} A_{i}, \forall e \in S.\)       (20)

 The previous equation can also be written as:

\(f_{e} \neq 0.\)       (21)

for every case where 𝑓𝑓𝑒𝑒 ∈ 𝔽𝔽2 r ∖ 0 o 𝑓𝑓𝑒𝑒 ∈ ℘.

7.1.2 Definition of the Constraints on Hops from an Outgoing to an Incoming Link

 Given the graph of Fig. 6, let 𝑓𝑓𝑠𝑠𝑣𝑣1 be a flow that emerges from 𝑠𝑠, which will arrive through the different links that form the path, and by the principle of the conservation of flow [21] [27], the following relationship of equality is deduced:

\(f_{s v_{1}}=f_{v_{1} v_{2}}=\cdots=f_{v_{j-1} v_{j}}=f_{v_{j} t}.\)       (22)

Fig. 6. The path from a source node to a sink node

 This equality should not be taken in a strictly literal sense. Equality, in this case, indicates that the flow to the left of equality contributes to the flow of the right. This means that it will be part of the linear combination built to obtain the flow through each output link at each intermediate node of the path. That is, the flow of one output link is increased by the flow preceding it within this equality.

 On a path from 𝑠𝑠 to sink 𝑡𝑡, let 𝑓𝑓𝑘𝑘 and 𝑓𝑓𝑙𝑙 be flows such that 𝑓𝑓𝑘𝑘 = 𝑓𝑓𝑙𝑙 through the links 𝑘𝑘 and 𝑙𝑙, where 𝑑𝑑 (𝑘𝑘) = 𝑜𝑜 (𝑙𝑙). From this equality two scenarios can be derived:

 (a) If 𝑑𝑑(𝑘𝑘) is a classical routing node, the incoming flow 𝑓𝑓𝑘𝑘 is the same outgoing flow 𝑓𝑓𝑙𝑙, since there is no linear coding at the output and the flow enters through the input link and passes identically to the output link.

 (b) If 𝑑𝑑(𝑘𝑘) is a coding node, the incoming flow 𝑓𝑓𝑘𝑘 is a component of the linear combination formed in the output links of the node, that is:

\(f_{l}=\cdots+f_{k}+\cdots.\)       (23)

 From the scenario in (a) and (22), if there is no coding node in the path from 𝑠𝑠 to 𝑡𝑡, then:

\(f_{S v_{1}}=f_{v_{j} t}.\)       (24)

 That is, the flow originates at source node 𝑠𝑠, which is transmitted through the outgoing link (𝑠𝑠, 𝑣𝑣1) and is the same in the incoming link (𝑣𝑣𝑗𝑗,𝑡𝑡) after 𝑗𝑗 hops.

 If there is a coding node in graph 𝐺𝐺, paths will be generated from 𝑠𝑠 to sink 𝑡𝑡 as shown in Fig. 7, where two outgoing paths from 𝑠𝑠 converge on the coding node 𝑣𝑣𝑗𝑗−1. Hence, the following two relationships of the equality of flows from 𝑠𝑠 to 𝑡𝑡 are established:

\(f_{s v_{1}}=f_{v_{1} v_{2}}=\cdots=f_{v_{j-1} v_{j}}=f_{v_{j} t}.\)       (25)

 and

\(f_{s w_{1}}=f_{w_{1} w_{2}}=\cdots=f_{v_{j-1} v_{j}}=f_{v_{j} t}.\)       (26)

 Fig. 7. The confluence of paths at the coding node

 It is observed that �𝑣𝑣𝑗𝑗−1, 𝑣𝑣𝑗𝑗� is a bottleneck link and flow 𝑓𝑓𝑣𝑣𝑗𝑗−1𝑣𝑣𝑗𝑗 originates in coding node 𝑣𝑣𝑗𝑗−1. Also, flows 𝑓𝑓𝑠𝑠𝑣𝑣1and 𝑓𝑓𝑠𝑠𝑤𝑤1 emerge from 𝑠𝑠 through links (𝑠𝑠, 𝑣𝑣1) and (𝑠𝑠, 𝑤𝑤1), respectively. According to (25) and (26), they contribute to 𝑓𝑓𝑣𝑣𝑗𝑗−1𝑣𝑣𝑗𝑗 , and according to (23), they form the linear combination:

\(f_{v_{j-1} v_{j}}=f_{s v_{1}}+f_{s w_{1}}.\)       (27)

 Therefore, from (25), (26) and (27), it is deduced that the flow in the incoming link �𝑣𝑣𝑗𝑗,𝑡𝑡� will directly depend on the outgoing flows from 𝑠𝑠 through the outgoing links (𝑠𝑠, 𝑣𝑣1) and (𝑠𝑠, 𝑤𝑤1) by the relation:

\(f_{v_{j} t}=f_{s v_{1}}+f_{s w_{1}}.\)       (28)

 In both (25) and (28), the flows in the incoming links to the node 𝑡𝑡 ∈ 𝑇𝑇 correspond to packets of size 𝑙𝑙-bits over the vector space 𝔽𝔽2 𝑙𝑙 as specified in section 3.3, which is the same as the packets of the outgoing flows.

7.1.3 Definition of Constraints in the Incoming Links

 In every sink node, 𝑡𝑡 ∈ 𝑇𝑇, the following rules must be observed:

 (a) Incoming flows must be non-zero; if 𝑓𝑓𝑣𝑣𝑗𝑗𝑡𝑡 is the flow arriving at 𝑡𝑡 and through the incoming link �𝑣𝑣𝑗𝑗,𝑡𝑡�, the packet flowing through this link and incoming to 𝑡𝑡 must have a tag or linear combination that is different to 0; that is, according to Fig. 8, it must be observed that:

\(f_{v_{j} t} \neq 0, \forall\left(v_{j}, t\right) \in L.\)       (29)

 (b) The linear combination of the incoming flows to a sink node must be non-zero; similarly, it must be observed that the linear combination of the packet codes (or tags) that enter each sink node through the incoming flows must be a value other than 0. That is, according to Fig. 8, the following constraint is established:

\(\sum_{j=1}^{r} f_{v_{j} t} \neq 0, \forall t \in T.\)       (30)

 (c) The matrix formed from codes that tag the incoming link flows must have a range 𝑟𝑟; the packet codes that arrive within each flow to the node 𝑡𝑡 must be linearly independent. That is, the bits that make up the code of each packet in each incoming flow to sink node 𝑡𝑡 form the rows of square matrix 𝑃𝑃 of dimension 𝑟𝑟 × 𝑟𝑟 with 𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟𝑟(𝑃𝑃) = 𝑟𝑟. The rows of 𝑃𝑃 represent the codes of the 𝑟𝑟-packets with size 𝑟𝑟-bits that enter the sink node.

 (d) The shape of the matrix 𝑃𝑃, which is constituted by the 𝑟𝑟-codes that identify the packets of the flows that arrive at a sink node in 𝑇𝑇, is:

\(P=\left[\begin{array}{c} c\left(p_{1}\right) \\ c\left(p_{2}\right) \\ \vdots \\ c\left(p_{r}\right) \end{array}\right]=\left[\begin{array}{cccc} b_{11} & b_{12} & \dots & b_{1 r} \\ b_{12} & b_{22} & \dots & b_{2 r} \\ \vdots & \vdots & \ddots & \vdots \\ b_{r 1} & b_{r 2} & \dots & b_{r r} \end{array}\right].\)       (31)

Fig. 8. Incoming links

 For example, if 𝑟𝑟 = 3, this would indicate a maximum flow for a multicast session of 3 packets generated at the source node and reaching each sink node. The length of the packets is indifferent; therefore, the codes are over the vector space 𝔽𝔽2 3. If it is assumed that a sink node receives the packets tagged with mnemonics 𝐴𝐴, 𝐴𝐴 + 𝐶𝐶 and 𝐵𝐵 + 𝐶𝐶 on its three links, then they correspond to the following binary codes:

\(\begin{aligned} &A \quad \quad=001=c\left(p_{1}\right)\\ &A+C=101=c\left(p_{2}\right)\\ &B+C=110=c\left(p_{3}\right) \end{aligned}\)

The corresponding matrix 𝑃𝑃 = � 0 0 1 1 0 1 1 1 0 � and its determinant is 1.

7.2 Creation Rules of the System of Constraints

7.2.1 Constraints on Outgoing Link Flows

 For each link 𝑒𝑒 of type 1 or 3, the variable names of the outgoing link flow (packet) codes are defined according to the following rule: if 𝑒𝑒 is an outgoing link in 𝑆𝑆 ∪ 𝐾𝐾 and its 𝑜𝑜(𝑒𝑒) = 𝑠𝑠, then the notation of the outgoing link flow variable is 𝑓𝑓𝑠𝑠_𝑑𝑑(𝑒𝑒), and its computational size is 𝑟𝑟-bits. The solutions for the outgoing flow 𝑓𝑓𝑠𝑠_𝑑𝑑(𝑒𝑒) are classified according to:

 (a) Simple packets: each 𝑓𝑓𝑠𝑠_𝑑𝑑(𝑒𝑒) corresponds to an integer power of 2 from 1 to 2𝑟𝑟:

\(f_{s_{-} d(e)}=1 \vee 2 \vee 4 \vee \ldots \vee 2^{r}, \text{where v is logical}\ or \text{ operator.}\)       (32)

 (b) Combined packets: each 𝑓𝑓𝑠𝑠_𝑑𝑑(𝑒𝑒) corresponds to an integer between 1 and 2𝑟𝑟:

\(f_{s_{-} d(e)}=\left[1,2^{r}\right] \neq 0\)       (33)

7.2.2 Constraints on incoming link flows

 For each link 𝑙𝑙 of type 2 or 3, the variable names of the incoming link flow (packet) codes are defined according to the following rule: if 𝑙𝑙 is a link in 𝐿𝐿 ∪ 𝐾𝐾 and its 𝑑𝑑(𝑙𝑙) = 𝑡𝑡,𝑡𝑡 ∈ 𝑇𝑇, then the notation of the incoming link flow code variable is 𝑓𝑓𝑜𝑜(𝑙𝑙)_𝑡𝑡, and its computational size is 𝑟𝑟-bits.

 The constraints are set with the support of the Reduced Source-Sinks Hop matrix 𝑄𝑄𝑟𝑟, where each 𝑄𝑄𝑟𝑟(𝑘𝑘, 𝑙𝑙) = 𝑗𝑗 indicates that there is a direct path with 𝑗𝑗 hops (1 ≤ 𝑗𝑗 ≤ 𝑛𝑛 − 1 and 𝐹𝐹𝑛𝑛 = 0) between the outgoing link 𝑘𝑘 and the incoming link 𝑙𝑙. 𝑄𝑄𝑟𝑟 𝑇𝑇(𝑙𝑙) is the column corresponding to the incoming link 𝑙𝑙 of the matrix 𝑄𝑄𝑟𝑟, and 𝑄𝑄𝑟𝑟 𝑇𝑇(𝑙𝑙, 𝑘𝑘) is the number of times that the flow coming from the outgoing link 𝑘𝑘 (noted as 𝑓𝑓𝑠𝑠_𝑑𝑑(𝑘𝑘)) will contribute to the linear combination built to obtain the flow of the incoming link 𝑙𝑙 (noted as 𝑓𝑓𝑜𝑜(𝑙𝑙)_𝑡𝑡). For an incoming link 𝑙𝑙, the flow 𝑓𝑓𝑜𝑜(𝑙𝑙)_𝑡𝑡 is written as a linear combination of the following number of added components:

\(\eta_{f_{o(l), t}}=\sum_{k \in S \cup K} Q_{r}^{T}(l, k).\)       (34)

 From (28), the flow 𝑓𝑓𝑜𝑜(𝑙𝑙)_𝑡𝑡 , in the incoming link 𝑙𝑙, is obtained through the following expression and formed by the added outgoing flows 𝑓𝑓𝑠𝑠_𝑑𝑑(𝑘𝑘),∀𝑘𝑘 ∈ 𝑆𝑆 ∪ 𝐾𝐾:

\(f_{o(l)_{-} t}=\sum_{k \in S \cup K} \sum_{i=1}^{Q_{r}^{T}(l, k)} f_{s_{-} d(k)}.\)       (35)

7.2.3 Constraints on incoming links and sink nodes

 The constraints given in section 7.1.3 must be met.

 (a) For each link 𝑙𝑙 of type 2 or 3 and considering (29), the flow must fulfill the expression:

\(f_{o(l), t} \neq 0, \forall t \in T, \forall l \text { with } d(l)=t.\)       (36)

 (b) For the linear combination of the flows in the incoming links 𝑙𝑙1, 𝑙𝑙2, … , 𝑙𝑙𝑟𝑟 to the sink node 𝑡𝑡 and considering (30), the following expression must be satisfied:

\(\sum_{i=1}^{r} f_{o\left(l_{i}\right)_{-} t} \neq 0, \forall t \in T, \forall l_{i} \text { with } d\left(l_{i}\right)=t.\)       (37)

 (c) To establish the linear independence between the codes of flows (packets) arriving at a sink node 𝑡𝑡 ∈ 𝑇𝑇, a matrix 𝑃𝑃𝑡𝑡 is constructed whose rows contain these codes. Each of the 𝑟𝑟-bits that make up a flow 𝑓𝑓𝑜𝑜(𝑙𝑙𝑖𝑖)_𝑡𝑡, will be denoted by 𝑓𝑓𝑜𝑜(𝑙𝑙𝑖𝑖)_𝑡𝑡 (𝑗𝑗) , where 1 ≤ 𝑖𝑖,𝑗𝑗 ≤ 𝑟𝑟:

\(P_{t}=\underset{r-bits}{\left[\begin{array}{c} f_{o}\left(l_{1}\right)_{-} t \\ f_{o}\left(l_{2}\right)_{-} t \\ \vdots \\ f_{o}\left(l_{r}\right)_{-} t \end{array}\right]}=\left[\begin{array}{cccc} f_{o\left(l_{1}\right)_{-} t}^{(1)} & f_{o\left(l_{1}\right)_{-}}^{(2)} & \dots & f_{o\left(l_{1}\right)_{-}}^{(r)} \\ f_{o\left(l_{2}\right)_{-} t}^{(1)} & f_{o\left(l_{2}\right)_{-} t}^{(2)} & \dots & f_{o\left(l_{2}\right)_{-}}^{(r)} \\ \vdots & \vdots & \ddots & \vdots \\ f_{o\left(l_{r}\right)_{-} t}^{(1)} & f^{(2)}_{o\left(l_{r}\right)_{-} t} & \dots & f^{(r)}_{o\left(l_{r}\right)_{-} t} \end{array}\right].\)       (38)

 The determinant of 𝑃𝑃𝑡𝑡 will be calculated by the method of minors and cofactors in the following manner for sink node 𝑡𝑡:

\(f_{o\left(l_{1}\right)_{-} t}^{(1)} * M_{11}+f_{o\left(l_{1}\right)_{t}}^{(2)} * M_{12}+\cdots+f_{o\left(l_{1}\right)_{t}}^{(r)} * M_{1 r} \neq 0.\)       (39)

 This determinant must be a non-zero value to fulfill the linear independence, that is:

\(\operatorname{det}\left(P_{t}\right)=\sum_{i=1}^{r} f_{o\left(l_{1}\right)_{t}}^{(i)} * M_{1 r} \neq 0, \forall t \in T.\)       (40)

 In short, a system of constraints is achieved and if solved will determine the value of the code that tags the packet emerging by each outgoing link that is born in the source node 𝑠𝑠. Similarly, the values of the codes that tag the packets arriving at each sink node in 𝑇𝑇 will be obtained. The system of constraints used to determine the solution to the multicast session of a single source node 𝑠𝑠 and the set of sink nodes 𝑇𝑇 is summarized as:

\(f_{s_{-} d(k)}=1 \vee 2 \vee 4 \vee \ldots \vee 2^{r} \quad \text { or } f_{s_{-} d(k)}=\left[1: 2^{r}\right] \neq 0.\)

\(f_{o(l)_{-} t}=\sum_{k \in S \cup K} \sum_{i=1}^{Q_{r}^{T}(l, k)} f_{s_{-} d(k)}.\)

\(f_{o(l)\_ t} \neq 0, \forall t \in T, \forall l \text { with } d(l)=t.\)

\(\sum_{i=1}^{r} f_{o\left(l_{i}\right)_{-} t} \neq 0, \forall t \in T, \forall l_{i} \text { with } d\left(l_{i}\right)=t.\)

\(P_{t}=\underset{r-bits}{\left[\begin{array}{c} f_{o}\left(l_{1}\right)_{-} t \\ f_{o}\left(l_{2}\right)_{-} t \\ \vdots \\ f_{o}\left(l_{r}\right)_{-} t \end{array}\right]}=\left[\begin{array}{cccc} f_{o\left(l_{1}\right)_{-} t}^{(1)} & f_{o\left(l_{1}\right)_{-}}^{(2)} & \dots & f_{o\left(l_{1}\right)_{-}}^{(r)} \\ f_{o\left(l_{2}\right)_{-} t}^{(1)} & f_{o\left(l_{2}\right)_{-} t}^{(2)} & \dots & f_{o\left(l_{2}\right)_{-}}^{(r)} \\ \vdots & \vdots & \ddots & \vdots \\ f_{o\left(l_{r}\right)_{-} t}^{(1)} & f^{(2)}_{o\left(l_{r}\right)_{-} t} & \dots & f^{(r)}_{o\left(l_{r}\right)_{-} t} \end{array}\right].\)

\(\operatorname{det}\left(P_{t}\right)=\sum_{i=1}^{r} f_{o\left(l_{1}\right)_{-} t}^{(i)} * M_{1 r} \neq 0, \forall t \in T.\)

8. Examples and Results

8.1 Example 1: Multicast session with nine nodes

8.1.1 System graphs and matrices

 Fig. 9(a) shows the graph of a multicast session with nine nodes and with a source node (𝑠𝑠 = 1), three sinks (𝑇𝑇 = {7,8,9}) and maximum flow of 𝑟𝑟 = 2 packets in 𝔽𝔽2 𝑙𝑙 . With a maximum flow of 2, the codes that will tag the packets are nonzero elements of the vector space 𝔽𝔽2 2. In addition, there is a coding node (node 5) that is not relevant to the model’s approach. Table 2 shows the links and their types. From this table, it is also inferred that the sets of outgoing and incoming links are constituted by: 𝑆𝑆 = {(1,2), (1,3), (1,4)} and 𝐿𝐿 = {(2,7), (6,7), (3,9), (6,8), (4,8), (6,9)}.

 Fig. 9(b) shows the DLLG for the multicast session with nine nodes. The longest path is three hops, and so it can only be iterated to 𝑛𝑛 = 3 and with 𝑛𝑛 = 4, 𝐹𝐹4 = 0. After obtaining the intermediate matrices, the Source-Sinks Hop matrix and the Reduced Source-Sinks Hop matrix are deduced as shown in Table 3 and Table 4, respectively.

Fig. 9(a) Multicast session for 𝐺𝐺 with nine nodes. (b) Directed Labeled Line Graph for 𝐺𝐺 with nine nodes

Table 2. Links table

Table 3. Source-Sinks Hop Matrix �

Table 4. Reduced Source-Sinks Hop Matrix 𝑄𝑄�

8.1.2 System constraints

 According to the multicast session graph represented in Fig. 9, the following set of constraints is derived from applying the model.

 (a) Constraints on the outgoing link flows:

   Case I: Flows with simple packets

\(f_{1\_{2}}=1 \vee 2 ; f_{1\_{3}}=1 \vee 2 ; f_{1\_{4}}=1 \vee 2\)

   Case II: Flows with combined packets

\(f_{1_{-} 2} \neq 0 ; f_{1\_{3}} \neq 0 ; f_{1\_{4}} \neq 0\)

 (b) Constraints on the incoming link flows:

   With the support of the Reduced Source-Sinks Hop matrix 𝑄𝑄𝑟𝑟, it is determined that

\(f_{2\_{7}}=f_{1\_ 2} ; f_{3\_{9}}=f_{1\_{3}} ; f_{4\_{8}}=f_{1\_{4}} ; f_{6\_{7}}=f_{1\_{2}}+f_{1\_{3}} ; f_{6\_{} 8}=f_{1\_{2}}+f_{1\_{3}} ; f_{6\_9}=f_{1\_2}+f_{1\_3}\)

 (c) Constraints on the incoming links and the sink nodes:

   (1) Non-zero incoming flows:

\(f_{2_{-} 7} \neq 0 ; f_{3_{-} 9} \neq 0 ; f_{4_{-} 8} \neq 0 ; f_{6_{-} 7} \neq 0 ; f_{6_{-} 8} \neq 0 ; f_{6_{-} 9} \neq 0\)

   (2) Non-zero linear combination of incoming flows to a sink node:

\(\begin{aligned} &f_{2_{-} 7}+f_{6_{-} 7} \neq 0\\ &f_{4\_8}+f_{6\_8} \neq 0\\ &f_{3_{-} 9}+f_{6\_{} 9} \neq 0 \end{aligned}\)

 (3) Matrix of tags sized 𝑟𝑟 = 2:

   The codes of this field are:

\(\wp=\mathbb{F}_{2}^{2} \backslash\{0\}=\{01,10,11\}\)

 Next, the code matrix and the independent linearity constraint between the incoming flows for each sink node 𝑇𝑇 are shown in Table 5.

Table 5. Code Matrix and Independent Linearity Constraints

8.1.3 System Solution

 When carrying this system to an equation solver (Z3[28] software, which is used as a theorem tester and first-order logic solver), the following results are obtained for each flow value (packet) in the outgoing links and each flow value (packet) in the incoming links:

 Case I: Flows with simple packets:

 Outgoing packet codes per outgoing link:

\(\begin{aligned} &f_{1\_{} 2}=2=B\\ &f_{1\_{3}}=1=A\\ &f_{1\_{} 4}=2=B \end{aligned}\)

The incoming packet codes per incoming link are shown in Table 6.

Table 6. Incoming Packet Codes per Incoming Link- Case I

 The multicast session graph with the solution is shown in Fig. 10(a).

 Case II: Flows with combined packets:

 Outgoing packet codes per outgoing link:

\(\begin{aligned} &f_{1\_{} 2}=1=A\\ &f_{1\_{3}}=3=A+B\\ &f_{1\_{4}}=3=A+B \end{aligned}\)

 The incoming packet codes per incoming link are shown in Table 7.

Table 7. Incoming Packet Codes per Incoming Link – Case II

 The multicast session graph with the solution is shown in Fig. 10(b).

Fig. 10. Solutions in graph 𝐺𝐺 with nine nodes.

8.2 Example 2: Multicast session with 18 nodes

8.2.1 System graphs and matrices

 Fig. 11(a) shows the graph of a multicast session with 18 nodes and with a source node (𝑠𝑠 = 1), three sinks (𝑇𝑇 = {18,19,20}) and maximum flow of 𝑟𝑟 = 4 packets in 𝔽𝔽2 𝑙𝑙 . With a maximum flow of 4, the codes that will tag the packets are nonzero elements of the vector space 𝔽𝔽2 4. Also, there are coding nodes (nodes 8 and 12) that are not relevant to the model’s approach. Table 8 shows the links and their types. From this table, it is also inferred that the sets of outgoing and incoming links are constituted by:

\(\begin{array}{c} S=\{(1,2),(1,3),(1,4),(1,5),(1,6),(1,7)\} \\ L=\left\{(13,18),(14,18),(15,18),(16,18),(6,19),(14,19),(15,19),(16,19),(10,20), \\ (14,20),(15,20),(16,20)\right\} \end{array}\)

 Fig. 11(b) shows the DLLG for the multicast session with 18 nodes. The longest path is three hops, and so it can only be iterated to 𝑛𝑛 = 3 and with 𝑛𝑛 = 4, 𝐹𝐹4 = 0. After obtaining the intermediate matrices, the Source-Sinks Hop matrix and the Reduced Source-Sinks Hop matrix are deduced as shown in Table 9 and Table 10, respectively.

Fig. 11(a) Multicast session for 𝐺𝐺 with 18 nodes. (b) Directed Labeled Line Graph for G with 18 nodes.

Table 8. Links table

8.2.2 System constraints

 According to the multicast session graph represented in Fig. 11, the following set of constraints is derived from applying the model.

 (a) Constraints on the outgoing link flows:

   Case I: Flows with simple packets

\(\begin{array}{l} f_{1\_2}=1 \vee 2 \vee 4 \vee 8 ; f_{1\_3}=1 \vee 2 \vee 4 \vee 8 ; f_{1\_4}=1 \vee 2 \vee 4 \vee 8 ; \\ f_{1\_5}=1 \vee 2 \vee 4 \vee 8 ; f_{1\_6}=1 \vee 2 \vee 4 \vee 8 ; f_{1\_7}=1 \vee 2 \vee 4 \vee 8 \end{array}\)

   Case II: Flows with combined packets

\(f_{1_{-} 2} \neq 0 ; f_{1_{-} 3} \neq 0 ; f_{1_{-} 4} \neq 0 ; f_{1_{-} 5} \neq 0 ; f_{1_{-} 6} \neq 0 ; f_{1_{-} 7} \neq 0\)

 (b) Constraints on the incoming link flows:

   With the support of the Reduced Source-Sinks Hop matrix 𝑄𝑄𝑟𝑟, it is determined that:

\(\begin{aligned} &f_{13\_{18}}=f_{1\_ 4} ; f_{14\_18}=f_{1\_2}+f_{1\_{3}} ; f_{15\_{18}}=f_{1\_{5}} ; f_{16\_{18}}=f_{1\_{6}}+f_{1\_{} 7} ; f_{6\_19}=f_{1\_{6}}\\ &\begin{array}{l} f_{14\_19}=f_{1\_2}+f_{1\_3} ; f_{15\_{19}}=f_{1\_{5}} ; f_{16\_{19}}=f_{1\_{6}}+f_{1\_{7}} ; f_{10\_{20}}=f_{1\_{4}} ; f_{14\_{20}}=f_{1\_{2}}+f_{1\_{3}} \\ f_{15\_{20}}=f_{1\_5} ; f_{16\_20}=f_{1\_{6}}+f_{1\_{7}} \end{array} \end{aligned}\)

Table 9. Source-Sinks Hop Matrix �

Table 10. Reduced Source-Sinks Hop Matrix 𝑄𝑄�

 (c) Constraints on the incoming links and the sink nodes:

   (1) Non-zero incoming flows:

\(\begin{aligned} &f_{13\_18} \neq 0 ; f_{14\_{18}} \neq 0 ; f_{15\_{18}} \neq 0 ; f_{16\_{18}} \neq 0 ; f_{6\_{1} 9} \neq 0 ; f_{14\_{19}} \neq 0 ; f_{15\_{19}} \neq 0;\\ &f_{16\_{19}} \neq 0 ; f_{10\_20} \neq 0 ; f_{14\_20} \neq 0 ; f_{15\_20} \neq 0 ; f_{16\_20} \neq 0 \end{aligned}\)

   (2) Non-zero linear combination of incoming flows to a sink node:

\(\begin{aligned} &f_{13\_{18}}+f_{14\_{18}}+f_{15\_{18}}+f_{16\_{18}} \neq 0\\ &f_{6\_{} 19}+f_{14\_{} 19}+f_{15\_{19}}+f_{16\_{19}} \neq 0\\ &f_{10\_{} 20}+f_{14\_{20}}+f_{15\_{20}}+f_{16\_20} \neq 0 \end{aligned}\)

 (3) Matrix of tags sized 𝑟𝑟 = 4:

   The codes of this field are:

\(\wp=\mathbb{F}_{2}^{4}\backslash\{0\}=\{0001,0010,0011,0100,0101,0110,0111,1000,1001,1010,1011,1100,1101,1110,1111\}\)

 Next, the code matrix and the independent linearity constraint between the incoming flows for each sink node 𝑇𝑇 are shown in Table 11.

Table 11. Code Matrix and Independent Linearity Constraints

8.2.3 System Solution

 The following results are obtained for each flow value (packet) in the outgoing and incoming links:

 Case I: Flows with simple packets:

 Outgoing packet codes per outgoing link:

\(\begin{aligned} &f_{1\_{} 2}=1=A\\ &f_{1\_{3}}=8=D \end{aligned}\)       \(\begin{aligned} &f_{1\_{4}}=1=A\\ &f_{1\_5}=4=C \end{aligned}\)       \(\begin{aligned} &f_{1\_{6}}=2=B\\ &f_{1\_{} 7}=1=A \end{aligned}\)

 The incoming packet codes per incoming link are shown in Table 12.

Table 12. Incoming Packet Codes per Incoming Link- Case I

 The multicast session graph with the solution is shown in Fig. 12(a).

 Case II: Flows with combined packets:

 Outgoing packet codes per outgoing link:

\(\begin{aligned} &f_{1\_{2}}=7=A+B+C\\ &f_{1\_{3}}=1=A \end{aligned}\)       \(\begin{aligned} &f_{1\_{} 4}=3=A+B\\ &f_{1\_{5}}=12=C+D \end{aligned}\)       \(\begin{aligned} &f_{1\_6}=3=A+B\\ &f_{1\_ 7}=11=A+B+D \end{aligned}\)

 The incoming packet codes per incoming link are shown in Table 13.

Table 13. Incoming Packet Codes per Incoming Link – Case II

 

 The multicast session graph with the solution is shown in Fig. 12(b).

Fig. 12. The solutions in graph 𝐺𝐺 with 18 nodes.

5. Conclusion

 Finding a solution to the multicast NC problem is one of the challenges addressed in several previous studies [2] [3] [16]. Also, the problem of multicast routing with NC has been addressed in [18] [19] [22] [23]. However, in these studies (especially the first one), the size of the field is associated with the solution, which is limited by the number of sinks that comprise the multicast network.

 To make the field size independent of the number of sinks, this work proposes finding a multicast solution based on the order to distribute 𝑟𝑟-packets, which constitute the maximum flow of the multicast session between the outgoing links from the source node and guarantees the delivery of the 𝑟𝑟-packets to each of the sink nodes.

 A code is defined to tag each packet within the network, which is within the range [1, 2𝑟𝑟 − 1]. The original or so-called simple packets within this study are tagged with the vectors 𝑢𝑢𝑖𝑖 in sequential order or with a defined mnemonic on an alphabet Σ. When packet coding is executed, it is also carrying out the linear combination of vectors 𝑢𝑢𝑖𝑖 using coding coefficients with a value of 1 defined in 𝔽𝔽2 or with the representation of the mnemonics of the alphabet using the xor (+) operator.

 From the matrix representation of the multicast session graph, the Reduced Source-Sink Hop matrix is constructed where each non-zero position indicates the number of times the outgoing link flow contributes at the incoming link to the constitution of a linear combination, which will enter the sink node at the end of this link.

 A system of constraints is established that allows solutions with either simple packet ordering in outgoing links or the use of combined packets. These constraints are constructed from the Reduced Source-Sink Hop matrix and consider the linear independence conditions at the sink nodes to assume the resolution of the system. When the conditions of linear independence are not met, the method will generate systems without solutions.

 A method is currently being developed to obtain all of the possible valid solutions for each case exposed. It is also expected that a proposal for multisource multicast (multicast multisession) systems, similar to this one, will be obtained. Furthermore, we are in the process of simulating a multicast session system that will allow us to observe its behavior beginning from the packets in the source node and include ordering in the outgoing links.