1 Introduction

Node/edge-Independent spanning trees (ISTs) can be used in reliable communication protocols [2, 20], one-to-all broadcasting [29], multi-node broadcasting [4], reliable broadcasting, and secure message distribution [3]. Therefore, the problem to construct multiple node/edge-ISTs for a given interconnection network is becoming an important issue.

We focus on the well-known two conjectures on the existence of ISTs in any interconnection network [20, 33] as follows:

Conjecture 1

Given an n-node-connected interconnection network G with \(n\ge 1\), there exist n node-ISTs rooted at an arbitrary node in G.

Conjecture 2

Given an n-edge-connected interconnection network G with \(n\ge 1\), there exist n edge-ISTs rooted at an arbitrary node in G.

Khuller and Schieber gave a proof that if any n-node-connected interconnection network has n node-ISTs, then any n-edge-connected interconnection network has n edge-ISTs [21]. However, Gopalan and Ramasubramanian found a counterexample to disprove Khuller and Schieber’s results [12]. Thus, either the node conjecture implies the edge conjecture or vice versa is still an open problem. For any interconnection network with \(n\le 4\), Conjectures 1 and 2 were solved in [9, 10, 13, 16, 20, 33]. For \(n\ge 5\), Conjectures 1 and 2 have been solved for some restricted classes of networks, such as planar networks [17], product networks [26], hypercubes [30, 32], locally twisted cubes [25], crossed cubes [5,6,7], Möbius cubes [8], even networks [22], odd networks [23], Gaussian networks [18], etc.

The line graph has received much attention by researchers in recent years. Results have been reported on edge-disjoint Hamilton cycles [24], traceability [28], number of spanning trees [11], structural properties [14], topological indices [27], treewidth [15], clique-perfectness [1], etc. Line graphs have applications in some data center networks by deploying servers on the edge of the original interconnection networks, such as SWCube [19], BCDC [31], etc. However, few results have been reported on the topic of independent spanning trees on line graphs. In this paper, we first adopt the definition of line graph G of n-edge-connected interconnection network \(G{'}\). We mainly obtained the following results:

  1. 1.

    If there are n edge-ISTs rooted at an arbitrary node in \(G{'}\), then there are n node-ISTs rooted at an arbitrary node in G.

  2. 2.

    An algorithm to construct n node-ISTs rooted at an arbitrary node in G based on the n edge-ISTs rooted at an arbitrary node in \(G{'}\) is presented.

  3. 3.

    Some simulation results on the line graphs of hypercubes based on Java and JUNG technology are shown.

Finally, we pointed out that the algorithm proposed in this paper can be used to construct node-independent spanning trees on SWCube and BCDC data center networks.

2 Preliminaries

2.1 Graph Terminology and Notation

An interconnection network can be abstracted as a graph G(V(G), E(G)), where V(G) denotes the node set and E(G) denotes the edge set. In this paper, graphs and networks are used interchangeably. We can also use the decimal numbers to denote the nodes in G.

Two \(\langle x,y \rangle \)-paths P and Q started at x and ended with y are edge-disjoint if \(E(P)\cap E(Q) = \varnothing \). Two \(\langle x,y \rangle \)-paths P and Q are internally node-disjoint if they are edge-disjoint and \(V(P)\cap V(Q)=\{x,y\}\). Two spanning trees \(T_{1}\) and \(T_{2}\), rooted at the same node u in G, are edge-independent if the \(\langle u,v \rangle \)-path in \(T_{1}\) and the \(\langle u,v \rangle \)-path in \(T_{2}\) are edge-disjoint for each \(v\in V(G)\backslash \{u\}\). Two spanning trees \(T_{1}\) and \(T_{2}\) rooted at u in network G are node-independent if the \(\langle u,v \rangle \)-path in \(T_{1}\) and the \(\langle u,v \rangle \)-path in \(T_{2}\) are internally node-disjoint for each \(v\in V(G)\backslash \{u\}\). Clearly, if two trees \(T_1\) and \(T_2\) are node-independent spanning trees, then they are also edge-independent spanning trees. We can also use path(u, v, T) to denote the \(\langle u,v \rangle \)-path in a tree T rooted at node u.

A set of spanning trees rooted at the same node in G are edge-independent (resp., node-independent) if they are pairwisely edge-independent (resp., node-independent). We also use node-ISTs (resp., edge-ISTs) for short to represent node-independent spanning trees (resp., edge-independent spanning trees).

2.2 A Class of Networks—Line Graphs

Given a network \(G{'}\), its line graph G is a graph such that each vertex of G represents an edge of \(G{'}\) and two vertices of G are adjacent if and only if their corresponding edges share a common endpoint (which are incident) in \(G{'}\). Now we provide Transformation 1 to demonstrate the construction of a line graph based on an existing network.

Transformation 1

Given a network \(G{'}\), we construct the line graph G by the following steps:

  1. (1)

    For every edge started from node x and ended at y in \(E(G{'})\), add a node [x, y] to network G, which is referred to as edge-node.

  2. (2)

    For every two adjacent edges (x, y) and (y, z) in \(G{'}\), connect [x, y] with [y, z] in G.

Figure 1 shows the network \(G{'}\) and its line graph G. Network G is derived from network \(G'\), where the number of edges in \(G'\) equals to the number of nodes in G.

Fig. 1.
figure 1

A network \(G{'}\) and its line graph G.

Full size image

Enlightened by Conjectures 1 and 2, the following interesting problem is naturally proposed.

Problem 1

Given n edge-ISTs in an n edge-connected network \(G{'}\), can we construct n node-ISTs in the line graph of \(G{'}\)?

In the following section, we try to answer this question by providing a general algorithm for any n-edge-connected network and its line graph.

3 Node-Independent Spanning Trees in Line Graphs

In this section, we first propose an algorithm, called NodeIST, to construct n node-ISTs in its line graph based on the n edge-ISTs in \(G{'}\). Then, we prove that the n trees obtained by Algorithm NodeIST based on Transformation 1 are n node-ISTs.

3.1 Construction Algorithm of Node-Independent Spanning Trees for Line Graphs

We now present an algorithm, called NodeIST, to construct n node-ISTs \(T_1\), \(T_2\), ..., \(T_n\) rooted at node [u, v] in the line graph G of \(G{'}\), based on the n edge-ISTs \(T_1{'}\), \(T_2{'}\), ..., \(T_n{'}\) rooted at u in n-edge-connected network \(G{'}\) and an edge (u, v). Since (u, v) and (v, u) are the same edge in \(G{'}\), we will let [u, v] and [v, u] denote the same node in G. For simplicity, we will always let an edge started at a smaller node and ended with a bigger node in the examples shown in Fig. 2. In Algorithm NodeIST, Step 1 is called to initialize trees \(T_1\), \(T_2\), ..., \(T_n\). By Step 2, the edge started at the root node [u, v] in each tree is determined and the edges derived from \(T_1{'}\), \(T_2{'}\), ..., \(T_n{'}\) are determined. After executing Step 3, each tree contains all the edges in G.

figure a

Example 1

Take the network \(G'\) and its line graph G in Fig. 1 for example. The three trees in Fig. 2(a) are not edge-ISTs in \(G'\), because the \(\langle 0,7 \rangle \)-path in the second tree and the \(\langle 0,7 \rangle \)-path in the third tree have the common edge (2, 6). In Fig. 2(b), the three trees are edge-ISTs rooted at node 0 in \(G'\) which are isomorphic to each other. Suppose that the three trees in Fig. 2(b) from left to right are \(T_1{'}\), \(T_2{'}\), and \(T_3{'}\). We let the three trees and node 1 as the input of Algorithm NodeIST. After the first step, we obtain trees \(T_1\), \(T_2\), and \(T_3\) shown in Fig. 2(c), the edge sets of which are empty and the node sets of which contain all the edge-nodes of \(G{'}\); after the second step, the three trees are shown in Fig. 2(d); lastly, the constructed node-ISTs are demonstrated in Fig. 2(e). We notice that each node in Fig. 2(b) is denoted by one decimal value, while each node in Fig. 2(c), (d), and (e) are denoted by two decimal values. Now, \(T_1\), \(T_2\), and \(T_3\) are three node-ISTs rooted at [0, 1] in G.

Fig. 2.
figure 2

(a) Wrong edge-ISTs. (b) Correct edge-ISTs. (c) Trees obtained by Step 1 of Algorithm NodeIST. (d) Trees obtained by Step 2 of Algorithm NodeIST. (e) Node-ISTs.

Full size image

3.2 Correctness of Node-Independent Spanning Trees Obtained by Algorithm NodeIST

By Algorithm NodeIST, every edge of G is contained in \(T_i\) for \(i=1,2,\ldots ,n\). Thus, we have the following lemma.

Lemma 1

\(T_i\) obtained by Algorithm NodeIST is a spanning tree in G for any integer i with \(1\le i\le n\).

Proof

By Algorithm NodeIST, \(T_i\) contains all the nodes in V(G) and it is easy to verify that \(T_i\) is a tree for any integer i with \(1\le i\le n\). Thus, the proof is completed. \(\Box \)

Suppose that T is a tree rooted at node [u, v] and [x, y] is an arbitrary node in the set \(V(G)\backslash \{[u,v]\}\). We use path([u, v], [x, y], T) to denote the node set of the path started at [u, v] and ended at [x, y] in T. By the definition of independent spanning trees, we present the following lemma to redefine node-independent.

Lemma 2

Let \(T_i\) and \(T_j\) be two different spanning trees rooted at node [u, v] in G where \(1\le i<j\le n\). \(T_i\) and \(T_j\) are node-independent if and only if for every node [x, y] in G, \([x,y]\ne [u,v]\), V(path([u, v], [x, y], \(T_i\))) \(\cap \) V(path([u, v], [x, y], \(T_j))=\{[u,v]\), \([x,y]\}\) and V(path([u, v], [x, y], \(T_i\))) \(\cup \) V(path([u, v], v[x, y], \(T_j))\supset \{[u,v]\), \([x,y]\}\).

Now we prove that the n trees obtained by Algorithm NodeIST are n node-independent spanning trees.

Theorem 1

\(T_1, T_2, \ldots , T_{n}\) obtained by Algorithm NodeIST are n node-independent spanning trees rooted at node [u, v] in G.

Proof

By Lemma 1, \(T_l\) obtained by Algorithm NodeIST is a spanning tree in G for any integer l with \(1\le l\le n\). Let [u, v] be the root node of each tree. We only need to prove that for any vertex \([x,y]\in V(G)\backslash \{[u,v]\}\) with \(x<y\), V(path([u, v], [x, y], \(T_i)\)) \(\cap \) V(path([u, v], [x, y], \(T_j))=\{[u,v], [x,y]\}\) and V(path([u, v], [x, y], \(T_i)\)) \(\cup \) V(path([u, v], [x, y], \(T_j))\supset \{[u,v]\), \([x,y]\}\). For any \(1\le i<j\le n\) and any edge \((x,y)\in E(G{'})\backslash \{(u,v)\}\), we have the following cases:

Case 1. \((x,y)\in E(T_i{'})\) and \((x,y)\in E(T_j{'})\). Then, the path(u, x, \(T_i{'})\) and path(u, x, \(T_j{'})\) are edge-disjoint (Similarly, path(u, y, \(T_i{'})\) and path(u, y, \(T_j{'})\) are edge-disjoint) by the hypothesis of Algorithm NodeIST. Thus, we can verify that E(path(u, x, \(T_i{'}))\cap E\)(path(u, x, \(T_j{'}))=\varnothing \).

By Algorithm NodeIST, all the edges in path(u, x, \(T_i{'})\) and path(u, x, \(T_j{'})\) are transformed into nodes and the connected two edges are transformed into two adjacent nodes. Since E(path(u, x, \(T_i{'}))\cap E(\)path(u, x, \(T_j{'}))=\varnothing \), we have V(path([u, v], [x, y], \(T_i)\)) \(\cap \) V(path([u, v], [x, y], \(T_j))=\{[u,v], [x,y]\}\).

Let the node adjacent to node u in \(T_i{'}\) be w and the node adjacent to node u in \(T_j{'}\) be z. Since \(T_i{'}\) and \(T_j{'}\) are edge-independent, \(w\ne z\). We have the following subcases.

Case 1.1. \(w=v\) and \(z\ne v\). It is clear that \(\{w, z, x, y, u, v\}\supset \{x, y, u, v\}\). By Algorithm NodeIST, \([u, z]\in \) V(path([u, v], [x, y], \(T_j)\)), which implies that V(path([u, v], [x, y], \(T_i)\)) \(\cup \) V(path([u, v], [x, y], \(T_j))\supset \{[u,v]\), \([x,y]\}\).

Case 1.2. \(w\ne v\) and \(z=v\). The proof is similar to Case 1.1.

Case 1.3. \(w\ne v\) and \(z\ne v\). It is clear that \(\{w, z, x, y, u, v\}\supset \{x, y, u, v\}\). By Algorithm NodeIST, \([u, w]\in \) V(path([u, v], [x, y], \(T_i)\)) and \([u, z]\in \) V(path([u, v], [x, y], \(T_j)\)), which implies that V(path([u, v], [x, y], \(T_i)\)) \(\cup \) V(path([u, v], [x, y], \(T_j))\supset \{[u,v]\), \([x,y]\}\).

Case 2. \((x,y)\not \in E(T_i{'})\) and \((x,y)\in E(T_j{'})\). By Algorithm NodeIST, if the node adjacent to node u in \(T_i{'}\) is v, we can verify that V(path([u, v], [x, y], \(T_i)\)) equals to the set of edge-nodes transformed from edges in path(u, x, \(T_i{'}\)) plus the set \(\{[x,y]\}\). Otherwise, V(path([u, v], [x, y], \(T_i)\)) equals to the set of edge-nodes transformed from edges in path(u, x, \(T_i{'}\)) plus the set \(\{[u,v], [x,y]\}\). The following proof is similar to Case 1.

Case 3. \((x,y)\in E(T_i{'})\) and \((x,y)\not \in E(T_j{'})\). The proof is similar to Case 2.

Case 4. \((x,y)\not \in E(T_i{'})\) and \((x,y)\not \in E(T_j{'})\). By Algorithm NodeIST, if the node adjacent to node u in \(T_i{'}\) is v, we can verify that V(path([u, v], [x, y], \(T_i)\)) equals to the set of edge-nodes transformed from edges in path(u, x, \(T_i{'}\)) plus the set \(\{[x,y]\}\). Otherwise, V(path([u, v], [x, y], \(T_i)\)) equals to the set of edge-nodes transformed from edges in path(u, x, \(T_i{'}\)) plus the set \(\{[u,v], [x,y]\}\). If the node adjacent to node u in \(T_j{'}\) is v, we can verify that V(path([u, v], [x, y], \(T_j)\)) equals to the set of edge-nodes transformed from edges in path(u, x, \(T_j{'}\)) plus the set \(\{[x,y]\}\). Otherwise, V(path([u, v], [x, y], \(T_j)\)) equals to the set of edge-nodes transformed from edges in path(u, x, \(T_j{'}\)) plus the set \(\{[u,v], [x,y]\}\). Since \(T_i{'}\) and \(T_j{'}\) are edge-independent, the node adjacent to node u in \(T_i{'}\) and \(T_j{'}\) are different. The following proof is similar to Case 1.

By Lemma 2, \(T_i\) and \(T_j\) are independent.

As a result, the theorem holds. \(\Box \)

Based on the n edge-independent spanning trees \(T_1{'}\), \(T_2{'}\), ..., \(T_n{'}\) rooted at u in n-edge-connected network \(G{'}\), v is an arbitrary adjacent node of u in \(G{'}\), where \(v>u\), the n node-independent spanning trees \(T_1\), \(T_2\), ..., \(T_n\) rooted at node [u, v] in G are constructed in parallel, thus we have the following theorem.

Theorem 2

The set of node-independent spanning trees \(T_1, T_2, \ldots , T_{n}\) obtained by Algorithm NodeIST can be obtained in O(N) time, where N is the number of nodes in G (or the number of edges in \(G'\)).

Based on the above discussion, we further present the following observations.

Observation 1

Algorithm NodeIST can be improved to obtain optimized node-ISTs. For example, in Fig. 2(e), if we let the node [1, 5] be adjacent to node [5, 7] in the third tree. Then, we can obtain another set of optimized node-ISTs with lower height.

Observation 2

Given n node-independent spanning trees in an n-node-connected network \(G{'}\), we can also construct n node-independent spanning trees in the line graph of \(G{'}\) based on Algorithm NodeIST.

Observation 3

It is also interesting to study another similar algorithm with the reverse direction based on Algorithm NodeIST.

4 Simulation of Node-ISTs on the Line Graphs of Hypercubes

As well-known interconnection networks, hypercubes have received much attention from researchers. In this section, we mainly simulate the construction of node-ISTs on hypercubes based on Java and JUNG technology. The n-dimensional hypercube \(Q_n\), is a graph consisting of \(2^n\) nodes and \(n2^{n-1}\) edges. Each node in \(Q_n\) is represented by binary strings of length n, and any two nodes in \(Q_n\) are adjacent whenever their corresponding strings differ in exactly one place. For example, Fig. 3 shows the four node-ISTs rooted at 0 in \(Q_4\) constructed by the algorithm in [30], the maximal height of which is 5. To simulate the duplicate nodes by JUNG technology, which do not admit the same node in one canvas, here, the prefixes A, B, C, D are only used to distinguish nodes, for example, A0, B0, C0, D0 are used to denote the same node 0.

Fig. 3.
figure 3

4 edge-ISTs rooted at 0 on 4-dimensional hypercube.

Full size image

Since hypercube is node-symmetric, the line graph of hypercube is also node-symmetric. If the nodes in 4-dimensional hypercube are 0, 1, ..., 15, then there are 32 edge-nodes in the line graph of 4-dimensional hypercube. For simplification, we use the numbers 1, 2, ..., 32 to denote the edge-nodes, the corresponding relation is shown in Table 1, which will be used in the simulation program to show the node-ISTs. Similarly, the prefixes a, b, c, d are only used by the program to distinguish nodes, for example, a1, b1, c1, d1 are used to denote the same node 1.

Table 1. Corresponding relations between numbers and edge-nodes.
Full size table

The node-ISTs rooted at 1 (corresponding to the edge-node [0, 1] in the line graph of 4-dimensional hypercube) in the line graph of 4-dimensional hypercube based on Algorithm NodeIST are shown in Fig. 4, the height of the four trees are 4, 5, 5, 5, respectively. Take the internally node-disjoint paths between 1 and 25, the 4 paths are as follows:

Fig. 4.
figure 4

The node-ISTs on the line graph of 4-dimensional hypercube.

Full size image

1\(\rightarrow \) 7\(\rightarrow \) 20\(\rightarrow \) 25

1\(\rightarrow \) 2\(\rightarrow \) 10\(\rightarrow \) 14\(\rightarrow \) 24\(\rightarrow \) 25

1\(\rightarrow \) 3\(\rightarrow \) 19\(\rightarrow \) 23\(\rightarrow \) 25

1\(\rightarrow \) 4\(\rightarrow \) 32\(\rightarrow \) 28\(\rightarrow \) 25

Fig. 5.
figure 5

The radial mode of node-ISTs.

Full size image

The paths denoted in edge-nodes are as follows:

\([0,1]\) \(\rightarrow \) \([1,5]\) \(\rightarrow \) \([5,13]\) \(\rightarrow \) [13, 15]

\([0,1]\) \(\rightarrow \) \([0,2]\) \(\rightarrow \) \([2,6]\) \(\rightarrow \) \([6,14]\) \(\rightarrow \) \([14,15]\) \(\rightarrow \) [13, 15]

\([0,1]\) \(\rightarrow \) \([0,4]\) \(\rightarrow \) \([4,12]\) \(\rightarrow \) \([12,13]\) \(\rightarrow \) [13, 15]

\([0,1]\) \(\rightarrow \) \([0,8]\) \(\rightarrow \) \([8,9]\) \(\rightarrow \) \([9,13]\) \(\rightarrow \) [13, 15]

It is easy to verify that the paths between the edge-node [0, 1] and any other edge-node are also internally node-disjoint.

The radial mode of the node-ISTs rooted at 1 are shown in Fig. 5. Here, the number of nodes deployed in the layers from the inside to the outside are 4, 9, 24, 39, 40, 12, respectively.

Simulation results show that the maximal height of the node-ISTs rooted at any node in the line graph of n-dimensional hypercube is n+1. We have the following observation.

Observation 4

The height of ISTs \(T_1\) and \(T_i\) in the line graph of n-dimensional hypercube are n and \(n+1\) for \(i=2, 3, \dots , n\), respectively, where \(n\ge 3\).

Observing that all the height of the n optimal node-ISTs rooted at any node in n-dimensional hypercube \(Q_n\) is \(n+1\) [30] and \(L(Q_n)\) contains more nodes than \(Q_n\) for \(n\ge 3\), the set of node-ISTs rooted at any node in \(L(Q_n)\) have advantages in the height with respect to the number of nodes.

If we abstract the interconnection network of severs in SWCube and BCDC, we obtain the line graph of generalized hypercube and crossed cube, respectively. Thus, we only need to construct independent spanning trees in the two networks. Let the input be the set of independent spanning trees from [26] and [31], we can use Algorithm NodeIST to construct independent spanning trees in the line graph of generalized hypercube and crossed cube, respectively.

5 Conclusions

In this paper, we have proved that if there are n edge-independent spanning trees rooted at an arbitrary node in the n-edge-connected network \(G{'}\), then there are n node-independent spanning trees rooted at an arbitrary node in the line graph of \(G{'}\). An algorithm to construct node-ISTs in G based on the node/edge-ISTs in \(G'\) is also presented. Some simulations of independent spanning trees on the line graphs of hypercubes were presented and we also pointed out that the algorithm proposed in this paper can be used to construct independent spanning trees on SWCube and BCDC data center networks. It is still interesting to prove that either the node conjecture implies the edge conjecture, or vice versa.