A New Approach to Generate Line Graphs of Undirected and Directed Graphs

1. Introduction

Let G(V,E) be a simple undirected graph where V = {v_i | i= 1,2,…,n } is the set of vertices and E ={ e_i | i= 1,2,…,m } the set of edges in G[West, 2000]. The line graph of G, denoted by L(G), is defined by a simple undirected graph with m vertices and q = -m + ( ∑ d_i ²)/2 edges where d_i denotes the degree of the vertex v_i . The vertices in L(G) correspond to the edges in G, and two vertices in L(G) are adjacent if the corresponding edges in G have a vertex in common. If B is the incidence matrix of G, it is known that the adjacency matrix of L(G) is BTB (modulo 2) and the time complexity of computing L(G) by this result is O(n5) [ Harary, 1994].

Line graph of a graph was independently discovered by many authors. Whitney was the first, but he did not assign any name to it. But others gave it different names. Hoffman: line graphs; Beineke: derived ; Kasteleyn : covering; Menon : adjoint. Ore: interchange graphs; Sabidussi: derivative; Seshu and Reed: edge-to-vertex. Line graphs have lots of applications in electrical engineering [ Harary, 1994], in communication networks [Krawczyk M et al, 2011], in ‘characterization of DNA sequences’ [ Kumar. V, 2010], in ‘Codes and designs’ [Fish.W et al, 2011] in VLSI design [Tatsuo.O et al, 1979], to mention a few.

In this paper a new matrix called degree edge matrix of an undirected graph G has been used as a data structure to develop an efficient algorithm to generate L(G) from G. An analogous development for generating line graph of a digraph has also been done. The computing time of the algorithms for generating line graphs of undirected graphs as well as directed graphs is O(n⁴) [Chartrand. and Oellermann, 1993]. Both the algorithms have been coded to C programming [ ] and tested for a large number of random graphs with varying densities. When the programs are run for undirected as well as directed graphs, it has been found that the actual computing time in both the cases is nearly 1% of the theoretical bound O(n⁴).

In section 2, we have given relevant definitions with illustrations. In section 3, a new method is developed with a new matrix to generate line graphs undirected graphs. In section 4, we have suggested how we can minimize actual computing time. An algorithm for generating line graph of an undirected graph is developed in this section. In section 5, an analogous development for generating line graph of a digraph is given. Programmers in C corresponding to these two algorithms are written and tested for random graphs with varying densities. Finally, the outputs are appended at the end of the paper.

2. Definitions:

Definition1. The edge matrix of G (n,m), denoted by E (G), is a ( 2 x m ) matrix defined by

where a column represents two end vertices of an edge of G.

The vertices of G are renamed as vij and the edges as (v1j,v2j) for ( i= 1,2; j= 1,2,...,m).

Obviously, for a graph without self loops v1j v2j, j= 1,2 ... , m

and without parallel edges $\begin{array}{c}\mathrm{v}1\mathrm{j}\\ \mathrm{v}2\mathrm{j}\end{array}$ $\ne$ $\begin{array}{c}\mathrm{v}1\mathrm{j}\\ \mathrm{v}2\mathrm{j}\end{array}$ , i$\le j\ne k\le m$Since G is undirected, without any loss of generality we can choose the end vertices of the edges ej as v1j < v2j for 1≤ j ≤ m.

Thus if we compare any two columns (say j the and k th) of E(G), then two possible cases may arise:

(a) ej = $\begin{array}{c}\mathrm{v}1\mathrm{j}\\ \mathrm{v}2\mathrm{j}\end{array}$ and ek = $\begin{array}{c}\mathrm{v}1\mathrm{k}\\ \mathrm{v}2\mathrm{k}\end{array}$ have one vertex in common

(b) ej = $\begin{array}{c}\mathrm{v}1\mathrm{j}\\ \mathrm{v}2\mathrm{j}\end{array}$ and ek = $\begin{array}{c}\mathrm{v}1\mathrm{k}\\ \mathrm{v}2\mathrm{k}\end{array}$ have no vertex in common

Thus the adjacency between the edges of G can be studied with the help of the edge matrix of the graph.

Definition 2. The degree of an edge e = (u,v), denoted by d(e), is defined by

d(e) = d(u) + d(v) - 2.

Definition 3. The degree edge matrix of G (n,m), denoted by DE(G), is a (3 x m) matrix defined by

where the submatrix formed by the first two rows of DE(G) is the matrix E(G) and v3j is the degree of the edge ej for j = 1,2,..,m . The third row of DE(G) will be called the degree edge vector of G. In an analogous way we can define the matrices EL(G) and DEL(G) as the Edge Matrix and Degree Edge Matrix respectively of L(G).

3. A New Method to Generate Line Graph of an Undirected Graph

We now present a new method based on the edge matrix of a graph G as data structure to generate line graph of an undirected graph. To explain the method we consider the following examples.

Here the number of edges is 5 and the degrees of the vertices are 2, 3, 2, and 3.

So the number of columns of EL(G) is q= -5 + ( 4+9+4+9)/2 = 8.

From the 1st and 2nd columns of E(G), we see e1 and e2 are adjacent, hence they will be the

vertices of L( G). So the 1st column of EL(G) is $\begin{array}{c}1\\ 2\end{array}$ (for convenience writing i for ei etc.)

Again, the lst and the 3rd columns of E(G) have an element (viz.2) in common,

the 2nd column of EL(G) will be $\begin{array}{c}1\\ 3\end{array}$Following this way we get the edge matrix of the line graph of G as

Since E(G) completely characterizes G, EL(G) does the same for L(G). The method of constructing EL(G) from E(G) as mentioned above is better than the existing method because the time complexity for computing EL(G) from E(G) is O(n4). This is due to the fact that the number of times the inner loop executed in the worst case is

(m-1)+(m-2)+ ^… +2+1= m(m-1)/2= O(m2) = O(n4).

4. Improvement of Actual Computing Time of Our Method

We can still make some improvement of the method mentioned in section 3 by slightly changing the input data structure. In the above method we have compared the 1st column with (m-1) columns (and the 2nd column with (m-2) columns and so on) without having any prior knowledge about the adjacency of the 1st edge (respectively the 2nd edge and so on) with others. So if, for example, the 1st edge is adjacent to p number of edges in G, we need not continue searching as soon as the comparison between the first edge and the adjacent p edges are over. So the effective computing time in most of the cases will decrease, although the theoretical bound of computing time remains the same. Therefore, from practical point of view it is better to use DE(G) for generating EL(G) or DEL(G). An algorithm for generating DEL(G) from DE(G) is given below.

Algorithm 1

Step 1 j=1

Step 2 If v_3j = 0 then go to Step 10

Step 3 k=j +l

Step 4 If v_3k = 0 then go to Step7.

Step 5 If the j th and the k th columns of DE(G) have one element in

common, then $\begin{array}{c}j\\ k\end{array}$ will be an edge in DEL(G) with degree

v_3j + v_3k – 2 /* original degrees are taken */

v_3j = v_3j -1, v_3k = v_3k -1. /* degree edge vector updated formulae */

Step 6 If deg( e_j) = 0 then go to Step10

Step 7 k=k+l

Step 8 If k > m then print" Error ": goto Step 14

Step 9 Go to Step 4

Step 10 j= j+l

Step 11 If j = m then print" Error ": goto Step 14

Step 12 Go to Step 2

Step 13 Print DEL(G).

Step 14. Stop.

Following the algorithm given above we demonstrate below how the actual computing time reduces for generating line graph from a given undirected graph.

Illustration: 2 DE(G) of the graph as shown in shown in Figure 1 is given by

Since v31 0, v32 0 and the corresponding columns have an element (here ‘1’) in common, thus $\begin{array}{c}1\\ 2\end{array}$will be an edge of L(G) with degree d(1)+ d(2) - 2= 4. (original values of v3j are stored in a linear array).

To update the degrees of the corresponding edges of G [ i.e., the elements of the third row of DE(G) ] we replace v31 by v31-1 and v32 by v32 -1. We next compare the first column (provided v31-1 0) and the third column (since v33 0) of DE(G). The moment the updated value of v31 becomes zero, we move to the next column v3j , 2 j m , provided its updated value is non-zero.

The degree of $\begin{array}{c}1\\ 2\end{array}$ in ELG = (deg of e1+deg of e2 in DE(G)) -2 = 3+3-2 = 4.

In this way we get the degree edge matrix [DEL(G)] of the line graph of the above graph as

Figure 2.

Figure 2.

The degree edge vector of the graph G is (3,3,3,4,3). We depict below how the degrees of the edges are changing when we implement Algorithm 1.

Degree edge vector Degree sum

(3 3 3 4 3 ) 16

(2 2 3 4 3 ) 14

(1 2 2 4 3 ) 12

(0 2 2 3 3 ) 10

(0 1 2 2 3 ) 8

(0 0 2 2 2 ) 6

(0 0 1 1 2 ) 4

(0 0 0 1 1 ) 2

(0 0 0 0 0 ) 0

The algorithm stops when the Degree sum becomes 0.

5. Line Graph of Directed Graph:

The concept of line graph of a graph can be extended to that of a digraph in an analogous way. But a difficulty arises in assigning a unique line digraph corresponding to a digraph, for there are three possible ways of defining the adjacency between any two arcs of a digraph. In fact, each of the following three types of adjacency (i) head-to-head, (ii) head-to-tail or tail-to-head and (iii) tail-to-tail corresponds to a line digraph and consequently they differ significantly. The convention is to accept “head-to-tail” adjacency for defining line graph of a digraph and we will stick to that. However, head-to-head and tail-to-tail adjacency relations are used in digraphs corresponding to food webs. Head-to head adjacency relation identifies species having common predators and thus the preys form Common enemy or Resource graphs; while tail-to tail adjacency relation identifies species having common preys and thus the predators form Competition or Consumer graphs [Mukherjee, 2010].

Definition 4. The degree of an arc ej =(vij,v2j), denoted by deg(ej), is defined by the out degree of the vertex v2j (i.e.,deg (ej)=d+ (v2j)).

Definition 5. The degree arc matrix of a digraph, denoted by DA(G), is defined by

where the j th column ,1 j m, denote the j th arc emanating from the vertex v1j and converging to the vertex v2j, and v3j=deg(ej). The third row of DA(G) will be called the degree arc vector of a digraph G.

Thus to compare whether ej and ek are adjacent, we are to check whether v2j is identical with v1k. If ej and ek are adjacent, we shall update the degree of the arcs just by reducing the degree of ej by unity only (i.e,v3j is updated by v3j-1, but v3k remains same).

In DAL(G), the degree of the arc $\begin{array}{c}j\\ k\end{array}$ will be calculated from DAG as:

degree of the arc ek = out degree of v2k.

The degree arc matrix is

Here v31 0, so we compare between e1 and e2. Since v21 v12, we next compare and see that

v21 = v13, hence $\begin{array}{c}1\\ 3\end{array}$ is an arc of the line digraph with degree2 ( since v33 = 2 ).

Since v31= 0 (updated value), we move to the second column and see that v32 0. We now compare e2 with e1 [although deg(e1) = 0 ].

Since v22 v11, we compare v22 with v13 and find v22 v13.

Next we see v22 = v14 . So $\begin{array}{c}2\\ 4\end{array}$ is an arc of the line digraph with degree1.

In this way we construct DAL(G) of the given DA(G) as

Algorithm for DAL(G) will differ from that of DEL(G) in the following points.

(i) If ej is adjacent to ek then only deg(ej) is updated.

(ii) To check whether ej is adjacent to ek, the columns of DAG are to be considered from the first column to the last column until (updated) v3j = 0. So k assumes the values 1,2,......j-1, j+1,....,m

Algorithm 2

Step 1 j=1

Step 2 If v_3j = 0 then go to Step 10

Step 3 k= l

Step 4 If k = j then go to Step7.

Step 5 If the j th and the k th columns of DA(G) have one element in common

Then $\begin{array}{c}j\\ k\end{array}$ will be an arc in DAL(G) with degree deg(e_k).

deg(e_j) = deg(e_j) – 1 /* Degree arc vector updated formulae*/

Step 6 If deg( e_j) = 0 then go to Step10

Step 7 k = k+l

Step 8 If k > m then print" Error ": goto Step 14

Step 9 Go to Step 3

Step 10 j= j+l

Step 11 If j = m then print" Error ": go to Step 14

Step 12 Go to Step 2

Step 13 Print DAL(G).

Step 14. Stop.

Illustration: 4 Let us consider the digraph as shown in Figure 3:

The degree arc matrix of the above digraph is

Here v₃₁≠ 0, so we compare between e₁ and e₂. Since v_{21 ≠} v₁₂, we next compare and see that v_{21 =} v₁₃, hence $\begin{array}{c}1\\ 3\end{array}$ is an arc of the line digraph with degree 2 ( since v₃₃=2).

We update the degree of the arc following Step 5. Since v₃₁= 0 ( updated value), we move to the second column and see that v₃₂≠ 0. We next compare e₂ with e₁ ( although deg(e₁) = 0). Since v_{22 ≠} v₁₁, we now compare v₂₂ with v₁₃ and see that v_{22 ≠} v₁₃ and then find v_{22 =} v₁₄.

So $\begin{array}{c}1\\ 4\end{array}$ will be an arc of the line digraph with degree 1.

In this way we construct DAL(G) from DA(G).

Illustration: 3: Let us consider the digraph

Figure 3.

Figure 3.

So

The degree arc vector of the digraph is ( 2,1,1,0,2,1). We demonstrate below how the degrees of the arcs are changing when we implement Algorithm 2.

Degree arc vector Degree sum

(1 1 2 1 1 0 ) 6

(0 1 2 1 1 0 ) 5

(0 0 2 1 1 0 ) 4

(0 0 1 1 1 0 ) 3

(0 0 0 1 1 0 ) 2

(0 0 0 0 1 0 ) 1

(0 0 0 0 0 0 ) 0

The algorithm stops when the Degree sum becomes 0.

Conclusion

The time complexity of computing the line graph of an undirected graph with n vertices and m edges by Algorithm 1 is O(n4). This is due to the fact that the number of times the inner loop executed in the worst case is

= (m-1)+(m-2)+ ...+2+1=m(m-1)/2=O(m2) = O(n4), [ since m= O(n2).]

We have run programs in C corresponding to Algorithm 1 and Algorithm 2 where the inputs are the random graphs with varying threshold values. We have calculated the actual number of comparisons taking place in our method and then compared it with the method given in [3]. Apart from theoretical point of view, the outputs of the program show that our method is efficient from computational aspects as well. It has been found that the actual computing time is nearly 1% of the bound O(n⁴).