A separator-based method for generating weakly chordal graphs

TL;DR

This paper introduces a new separator-based algorithm for efficiently generating weakly chordal graphs with specified numbers of vertices and edges, maintaining weak chordality throughout the process.

Contribution

It presents a novel separator-based method for constructing weakly chordal graphs that ensures the property is preserved during edge insertions, improving over existing algorithms.

Findings

The algorithm guarantees the graph remains weakly chordal after each insertion.

Insertion query time complexity is O(n^3).

Compared to existing methods, it offers a more efficient generation process.

Abstract

We propose a scheme for generating a weakly chordal graph on n vertices with m edges. In this method, we first construct a tree and then generate an orthogonal layout (which is a weakly chordal graph on the n vertices) based on this tree. In the next and final step, we insert additional edges to give us a weakly chordal graph on m edges. Our algorithm ensures that the graph remains weakly chordal after each edge is inserted. The time complexity of an insertion query is O(n^3) time and an insertion takes constant time. On the other hand, a generation algorithm based on finding a 2-pair takes O(nm) time using the algorithm of Arikati and Rangan [1].

Full text

1 Introduction

In this paper $G=(V,E)$ will be used to denote a graph with $|V|=n$ vertices and $|E|=m$ edges. $G$ is chordal if it has no chordless cycles of size four or more. However, as the following example shows (Figure 1), its complement $\overline{G}$ can contain chordless 4-cycles.

This suggested the generalization of chordal graphs to weakly chordal (or weakly triangulated) graphs as those graphs $G$ such that neither $G$ nor its complement $\overline{G}$ contains chordless cycles of size five or greater [3]. From the symmetry of the definition it follows that $\overline{G}$ is also weakly chordal. Figure 2 shows an example of a weakly chordal graph ($G$) along with its complement ($\overline{G}$).

In this paper we address the algorithmic problem of generating weakly chordal graphs. While the problem of generating graphs uniformly at random has received much attention (see [11], [12], [13], [7]), little is known about this problem. There are many situations where we would like to generate instances of these to test algorithms for weakly chordal graphs. For instance, in [8] the authors generate all linear layouts of weakly chordal graphs. A generation mechanism can be used to provide input instances for this algorithm.

An edge $e$ in $G$ is peripheral if it is not the middle edge of a chordless path $P_{4}$ spanning four vertices of $G$. In [4], Hayward proposed the following constructive characterization of weakly chordal graphs, based on the notion of a peripheral edge.

Theorem 1.1

[4]** A graph is weakly chordal if and only if it can be generated in the following manner:

Start with an empty graph $G_{0}$. 2. 2.

Repeatedly add an edge $e_{j}$ to the graph $G_{j-1}$ to create the graph $G_{j}$ such that $e_{j}$ is a peripheral edge of $G_{j}$.

This is analogous to a similar characterization for chordal graphs by Fulkerson and Gross [2]. No details were provided as to how to decide if an edge is peripheral and the complexity of the generation method. The proof of this theorem uses the notion of a two-pair and a generation method can be devised based on this. A pair of vertices $\{u,v\}$ in $G$ is a two-pair if the only chordless paths between the $u$ and $v$ are of length 2. Interestingly enough, a weakly chordal graph that is not a clique has a two-pair [5]. Furthermore, let $\{u,v\}$ be a two-pair in an arbitrary graph $G$. Then $G+\{u,v\}$ is weakly chordal iff $G$ is weakly chordal [10]. We can then generate a weakly chordal graph on $n$ vertices by starting with a tree (which trivially satisfies the definition of weak chordality) and repeatedly find a two-pair $\{u,v\}$ and add to $G$ the edge joining $u$ to $v$. To find a two-pair we can use an $O(mn)$ algorithm due to Arikati and Rangan [1]. Unfortunately, this does not allow us to exploit the structural properties of a weakly chordal graph.

Thus in this paper we propose a separator-based strategy that generalizes an algorithm due to Markenzon [6] for generating chordal graphs and allows us to exploit the structural properties of a weakly triangulated graph.

The paper is organized thus. In the next section, we collect in one place some common graph-theoretic terminology used throughout the paper and also add a brief review of Markenzon’s incremental method [6] for generating chordal graphs. The following section contains details of our algorithm, beginning with a brief overview. The final section contains some concluding remarks and suggestions for further research.

1.1 Preliminaries

For a given $G$, let $n=|V|$ and $m=|E|$. The neighborhood of a vertex $v$ is denoted as $N(v)$ where $N(v)=\{u\in V:(u,v)\in E\}$. The closed neighborhood of a vertex $v$, denoted by $N[v]$ is $N(v)\cup{v}$. The complement of a graph $G$, denoted by $\overline{G}$, contains the same set of vertices such that two vertices of $\overline{G}$ are adjacent iff they are not adjacent in $G$. The graph $\overline{G}$ in Fig 2(b) is the complement of the graph $G$ (Fig 2(a)).

For any vertex set $S\subseteq V$, the edge set $E(S)\subseteq E$ is defined to be $E(S)=\{(u,v)\in E|(u,v)\in S\}$. Let $G[S]$ denote the subgraph of $G$ induced by $S$, namely the subgraph $(S,E(S))$. In other words, an induced subgraph is a subset of the vertices of a graph $G$ together with any edges whose endpoints are both in this subset.

A path in a graph $G$ is a sequence of vertices $v_{i},v_{i+1},\dots.,v_{k}$, where $\{v_{j},v_{j+1}\}$ for $j=i,i+1,\dots.,k-1$, is an edge of $G$. The first vertex is known as the start vertex, the last vertex is called the end vertex, and the remaining vertices in the path are known as internal vertices. A cycle is a closed path where the start vertex and the end vertex coincide. The size of a cycle is the number of edges in it. A clique in $G$ is a subset of vertices $(S\subseteq V)$ of $G$ such that the induced subgraph $G[S]$ is complete. A maximal clique is a clique that cannot be extended by including one more adjacent vertex. A graph on $n$ vertices that forms a clique on $n$ vertices is called a complete graph ($K_{n}$).

Based on the given $n$ and $m$, Markenzon’s method starts by generating a labeled tree on $n$ vertices using Prüfer’s scheme [9]. Next, an edge is inserted in each iteration to reach $m$. The algorithm picks a pair of vertices $\{u,v\}$ and checks whether $v$ is reachable from $u$ on the induced graph $G[S]$, where $S=V-I_{u,v}$ and $I_{u,v}=N(u)\cap N(v)$. If $G[S]$ is connected, then a path exists between $u$ and $v$ and thus $G+\{u,v\}$ is not chordal; otherwise, the augmented graph $G+\{u,v\}$ is chordal. To make the search for a path efficient, the method reduces the set $S$ from $V-I_{u,v}$ to $N(x)-I_{u,v}$, for any $x\in I_{u,v}$. The correctness of the algorithm was established by proving the following theorem.

Theorem 1.2

[6]** Let $G=(V,E)$ be a connected chordal graph and $u,v\in V,(u,v)\notin E$. The augmented graph $G+\{u,v\}$ is chordal if and only if $G[V-I_{u,v}]$ is not connected.

2 Generation of Weakly Chordal Graphs

2.1 Overview of the Method

Just as in Markenzon’s incremental method for chordal graphs, we take as input the number of vertices, $n$, and the number of edges, $m$, of the weakly chordal graph $G$ to be generated. Our proposed method starts with generating a tree. With the help of a tree, we construct an orthogonal layout made up of 4-cycles, each cycle corresponding to a node of this tree. We then insert additional edges into this initial layout to ensure that the final graph has $m$ edges. Trees are weakly chordal graphs and so is the initial orthogonal layout of the 4-cycles. Additional edges are introduced to reach the target value of $m$ by picking a pair of vertices $u$ and $v$ at random and checking if the augmented graph $G+\{u,v\}$ remains weakly chordal.

If $u$ and $v$ have some common neighbors ($I_{u,v}\neq\emptyset$), we remove those common neighbors and check whether the removal of the common neighbors separates $u$ and $v$, leaving them in different components. We create an induced graph on a set of vertices called $AuxNodes$ that contain the neighbors of neighbors of $I_{u,v}$ to check whether $u$ and $v$ are in different components. If so we insert an edge between $u$ and $v$, else we search for shortest paths between $u$ and $v$. We do not insert the edge $\{u,v\}$ if the length of the shortest path is greater than $3$. Otherwise, we have to check for other conditions, such as single or multiple $P_{3}$ ($P_{3}$ denotes a path of length 3), forbidden configurations, alternate longer paths between $u$ and $v$ to decide whether the insertion of $\{u,v\}$ preserves weak chordality.

If there are no common neighbors ($I_{u,v}=\emptyset$) between $u$ and $v$, we apply the same rules to this case as when $I_{u,v}$ does not separate $u$ and $v$ (as explained in the previous paragraph). The only difference is that here we have to consider the entire graph to search for shortest paths between $u$ and $v$ but the other subsequent steps remain the same. All the phases of this generation method are explained in full details in the next subsections.

2.2 Phase 1: Generation of Tree

We generate a tree, $T$, on $\lceil{\frac{n}{2}}\rceil$ nodes that each node is of degree-4 at most as follows. Starting with a single node, we add new ones either by splitting an edge into two or joining a new node to one of the existing nodes, chosen at random. After $\lceil{\frac{n}{2}}\rceil$ nodes, have been added, we traverse the tree to check for adjacent degree-4 nodes. If such a pair is found, we separate them by introducing a new node adjacent to both. We define $k$ as the number of nodes in the tree ($T$).

2.3 Phase 2: Generation of Initial Layout

In this phase, we generate an orthogonal initial layout of $T$. For each node in $T$, we create a four-cycle. Figure 3(a) shows a tree $T$ with two nodes, $a$ and $b$. For node $a$ in the tree, we generate a four-cycle and for node $b$ we generate another four-cycle adjacent to the existing four-cycle because node $a$ is adjacent to node $b$ in the tree. The corresponding layout is shown in Figure 3(b). We define this as the initial layout. For the example tree of Figure 3(c), the corresponding initial layout is shown in Figure 3(d).

As explained in the first phase, after generating a tree, if two degree-$4$ nodes are adjacent, we insert a new node between them to separate them (see Figure 3(e), 3(f), and 3(g)). Since a four-cycle has only four sides, two degree-$4$ nodes cannot be adjacent. As we are interested in generating proper weakly chordal graphs (and not just chordal graphs), we want to have four-cycles in the initial layout. At this point, if the orthogonal layout has more than $n$ vertices, we delete vertices from four cycles to make it equal to $n$. To delete a vertex, we select vertices having degree at most two. If the number of edges in the initial layout is greater than or equal to the given $m$, the algorithm stops and returns the layout as a weakly chordal graph. Otherwise, it takes the difference of the number of edges and inserts that many edges in the initial layout to produce a weakly chordal graph. Now we denote the number of edges as $m^{\prime}$ in the initial orthogonal layout.

2.4 Phase 3: Generation of Weakly Chordal Graph

After generating an initial layout, we insert $(m-m^{\prime})$ edges to generate weakly chordal graphs. We divide the insertion of an edge $\{u,v\}$ into two cases. The first case considers when $I_{u,v}$ is non-empty and the second case is when $I_{u,v}$ is empty, where $I_{u,v}=N(u)\cap N(v)$, represents the set of common neighbors between $u$ and $v$. Let’s discuss the case first when $I_{u,v}$ is non-empty.

2.4.1 Case 1: $I_{u,v}$ is non-empty

Since $I_{u,v}$ is non-empty, we need to check whether the removal of $I_{u,v}$ separates $u$ and $v$. To do this, we create an induced graph, called $AuxGraph$ on the set of vertices $V-I_{u,v}$. Now we perform a breadth-first search on $AuxGraph$, starting at $u$ and if $v$ has not been reached, then the augmented graph $G+\{u,v\}$ is weakly chordal. Thus we can insert an edge $\{u,v\}$ in the weakly chordal graph $G$ because the removal of their common neighbors ($I_{u,v}$) in $AuxGraph$ leaves $u$ and $v$ in different components. Instead of searching for a path on this large set of vertices, we consider an induced graph on a smaller subset of vertices. In [6], the authors built the induced graph on the neighbors of any vertex $x$ in $I_{u,v}$ for the chordal graph. But here we need to consider the neighbors of neighbors of every vertex $x$ in $I_{u,v}$ to explore paths between $u$ and $v$. Formally the set of vertices included in $AuxNodes$ can be defined as $(\bigcup_{x\in I_{u,v}}(N(N(x\setminus\{u,v\}))\cup N(x)))\cup N(u)\cup N(v)-I_{u,v}$.

Consider the graph shown in Figure 4. We want to introduce an edge between $u$ and $v$ which is not allowed because the insertion violates the property of the weakly chordal graph. There is only one common neighbor $I_{u,v}=\{a\}$ between $u$ and $v$. The $N(a)$ is $\{b,d\}$ and the induced graph on $\{u,v,b,d\}$ shows there is no path between $u$ and $v$ but there are longer paths ($u-c-d-e-v$ and $u-c-d-b-v$) exist between $u$ and $v$. These paths are discoverable if we take the neighbors of neighbors of $a$ and build $AuxGraph$ on $AuxNodes$ as defined above. The $N(N(a))$ includes $\{b,c,d,e\}$ and thus the $AuxNodes$ comprises $\{u,v,b,c,d,e\}$.

This is the first part of case 1 that we define as case 1.1. This idea is extended from [6], where the authors insert an edge $\{u,v\}$ in a chordal graph when $v$ has not been reached from $u$ during a breadth-first search on $AuxGraph$. What happens if $v$ is reachable from $u$ in a weakly chordal graph?

In a weakly chordal graph we may be able to insert an edge $\{u,v\}$ even when a path exists between $u$ and $v$. In a chordal graph, the separators are cliques but in a weakly chordal graph, the separators may not necessarily cliques. Now we have to explore all the shortest paths of length 3 or more between $u$ and $v$. If there is a path longer than $P_{3}$ exists, we do not insert $\{u,v\}$ and choose another pair of vertices, otherwise, we check the other conditions for the possibility of insertion of $\{u,v\}$. We call this case 1.2. Again we divide this case 1.2 into two subcases: if there is a single $P_{3}$ then we called case 1.2.1 and otherwise case 1.2.2 for multiple $P_{3}$.

Case 1.2.1: We find the neighbors of the shortest path. If the neighborhood of the shortest path is empty, we insert an edge $\{u,v\}$, otherwise, we find the alternate paths in the entire graph. Instead of searching for alternate paths in the entire graph, we search for alternate paths on different induced graphs created on $\{N(N(SP\setminus\{u,v\}))\}$ (where $SP$ represents the shortest path between $u$ and $v$) by removing both the internal vertices of $SP$ or exactly one of them to find alternate paths between $u$ and $v$. Consider the two situations shown in Figure 5 where $u-x-y-v$ is a path of length $3$. In Figure 5(a), each vertex on $P_{i}$, $i>3$ is a neighbor of either $x$ or $y$ but in Figure 5(b) there exists a vertex ($b$) which is neither a neighbor of $x$ nor $y$. Thus we are interested in the neighbors of neighbors of the shortest path to discover other alternate paths.

The alternate paths may exist via some of the vertices in the shortest path and/or other vertices including in the neighbors or the neighbors of neighbors of the shortest path or disjoint path via the vertices not included in $SP$. If no alternate paths exist, we can insert an edge $\{u,v\}$, otherwise we do not insert $\{u,v\}$ and choose another pair of vertices. The algorithm 1 explains the Case 1.2.1 (for a single shortest path).

Case 1.2.2: In the case of multiple shortest paths, first we need to check for forbidden configurations. To define a forbidden configuration, let’s consider the graphs shown in Figure 6. In Figure 6(a), we can insert an edge $\{u,v\}$ because it does not create any chordless five cycles or more in the graph $G$, but it creates a chordless six cycle in the complement graph as illustrated in Figure 6(b). As we know from the definition of the weakly chordal graph, a graph $G$ is weakly chordal if neither $G$ nor its complement $\overline{G}$ contains a chordless cycle of size $5$ or more. But $G+\{u,v\}$ creates a chordless six cycle in $\overline{G}$. Thus, we cannot add $\{u,v\}$ in $G$. The forbidden configuration checking is required when two or more shortest $P_{3}$ paths exist between $u$ and $v$ and the checking has to be done by considering all pairwise disjoint shortest paths. Figure 7 illustrates other configurations where adding $\{u,v\}$ to $G$ may be allowed.

After checking forbidden configurations, the next step is to check for alternate longer paths between $u$ and $v$. Like case 1.2.1, instead of searching for alternate longer paths in the entire graph we do the search on the different induced graphs created on $\{N(N(allSP\setminus\{u,v\}))\}$ (where $allSP$ represents all the shortest paths between $u$ and $v$ containing the set of vertices in the paths including two endpoints) by removing all the internal vertices of $allSP$ or exactly one of them to find alternate paths between $u$ and $v$. The alternate paths may exist via some of the vertices in the shortest path and/or the other vertices including in the neighbors/the neighbors of neighbors of the shortest path or disjoint path via the vertices not included in $allSP$. These two scenarios are illustrated in Figure 8.

2.4.2 Case 2: $I_{u,v}$ is empty

In this case, there are no common neighbors of $u$ and $v$ but a path exists between $u$ and $v$. This case can be solved in a similar way as for case 1.2. Here the $AuxGraph$ is the entire graph because $I_{u,v}$ is empty. If any of the paths is greater than $P_{3}$, we do not insert $\{u,v\}$ and choose another pair of vertices. Otherwise, we apply the same single shortest path case 1.2.1 and multiple shortest path case 1.2.2 to check if the addition of $\{u,v\}$ keeps the graph weakly chordal or not. Here we define the single shortest path case as case 2.1 and multiple shortest paths case as case 2.2. The details of all the above cases are formally described in algorithm 3.

2.4.3 An Example

Figure 9 shows an example for the generation of weakly chordal graph for $n=8$ and $m=12$. All the phases are shown in Figure 9. Figure 9(a) shows the tree on $\lceil{\frac{n}{2}}\rceil$ nodes. There are three nodes in the tree and for each node in the tree, we create an orthogonal initial layout which is shown in Figure 9(b) where $n=8$ and $m^{\prime}=10$. We assign the labels of vertices as $0\dots 7$ in the initial layout. We need to insert $(m-m^{\prime})=2$ more edges in the initial layout to generate a weakly chordal graph for the given input.

Assume we want to insert edge $\{3,4\}$. The insertion of an edge between $3$ and $4$ falls into the case where $I_{3,4}$ is non-empty. Since the removal of $I_{3,4}$ leaves vertices $3$ and $4$ in two different components, so we can insert an edge between vertices $3$ and $4$ according to case 1.1 as shown in Figure 9(c). Now we want to insert edge $\{3,6\}$. The insertion of an edge between $3$ and $6$ falls into the case 1.2.1 because the removal of their common neighbor $\{5\}$ does not separate $3$ and $6$. The $N(5)$ is $\{3,4,6\}$ and the $N(N(\{3,4,6\})\setminus\{3,6\})$ is $\{0,5,7,3\}$. Now we create the $AuxGraph$ on the $AuxNodes=\{0,2,3,4,6,7\}$ and then we search for the paths from $3$ to $6$. There is a single shortest path $SP=\{3,4,7,6\}$ exist that means it falls into case 1.2.1. We compute $N(SP)=\{0,2,4,3,6,7\}$ and the $N(SP)\setminus SP\neq\emptyset$, so we need to compute $\{N(N(SP\setminus\{3,6\}))\}$ which is $\{3,4,0,7,6\}$ and create induced graph on these set of vertices. To discover disjoint or shared alternate paths from $3$ to $6$ we create different induced graphs by removing some vertices from the above-computed set of vertices. But there is no such path exists and we can insert an edge between $3$ and $6$.

2.5 Time Complexity

The tree generation is the first phase in the proposed approach and can be constructed in time $O(k)$ where $k$ is the number of nodes in a tree. For $k$ nodes in the tree, we insert $3k+1$ edges in the layout and each edge insertion can be done in constant time. So the initial layout can be generated in $O(k)$ time.

In the third phase, the pair of vertices $\{u,v\}$ is chosen at random to insert an edge between them. Two types of failures may arise. One is that the pair of vertices $\{u,v\}$ corresponds to an existent edge and the other is the addition of $\{u,v\}$ violates weak chordality property. To avoid the first type of failures either we can maintain a list of edges (those are present in the complement graph) not present in the current graph or we can check the existence of an edge in constant time by maintaining the adjacency matrix representation of the current graph.

Computing the neighborhood of a vertex takes linear time. Thus step 7 takes linear time. By amortizing over the edges we can see that step 8 takes linear time in the number of edges $m$ and the number of vertices $n$. Thus each of the neighborhood computations take linear time. The $AuxGraph$ can be created in linear time on the number of vertices in the $AuxNodes$. Using breadth-first search (BFS), we find whether there is a path exist between $u$ and $v$ in linear time. To find all $P_{3}$ shortest paths we also use BFS by keeping track of all predecessors between $u$ and $v$. All the operations including neighborhood computations, induced graph creations, and finding alternate longer paths take linear time (see step 23 and step 32).

For steps 25 and 34, the forbidden configuration checking is required when two or more shortest $P_{3}$ paths exist between $u$ and $v$ and the checking has to be done by considering all pairwise disjoint shortest paths. The checking is performed by the presence of one of the cross edges (an edge from one of the internal nodes from one shortest path to the alternate internal node of another shortest path) on the induced graph on a pair of disjoint shortest paths. There are at most $O(n^{3})$ pairs of mutually disjoint $P_{3}$ paths between $u$ and $v$ and thus the step takes $O(n^{3})$ time (see Appendix). We use BFS to find an alternate longer path between $u$ and $v$. Since there are at most $O(n^{2})$ multiple $P_{3}$ paths between $u$ and $v$ and thus in total we spend $O(n^{2})$ time. In the worst case, an insertion query runs in $O(n^{3})$ time.

The insertion of $\{u,v\}$ is performed in time $O(1)$ because we need to insert $u$ in the neighborhood of $v$ and $v$ in the neighborhood of $u$.

3 Conclusions

We have proposed a method for the generation of weakly chordal graphs. We have implemented the proposed algorithm in Python. An interesting open problem is to investigate how to generate weakly chordal graphs uniformly at random. This requires coming up with a scheme for counting the number of labeled weakly chordal graphs on $n$ vertices having $m$ edges. If we could also determine the probability distribution underlying our algorithm for generating weakly chordal graphs, then we could compute the relative entropy between the two distributions to estimate how close our algorithm is to generating weakly chordal graphs uniformly at random.

4 Appendix

We are interested in finding all $P_{3}$ shortest paths between $u$ and $v$ (see Figure 10). Suppose there are $n$ vertices in the graph. Let $\{v_{1},v_{2},\dots,v_{l}\}$ be the set of vertices adjacent to $v$ that lie on the $P_{3}$ shortest paths between $u$ and $v$. Likewise, let $\{v_{1}^{\prime},v_{2}^{\prime},v_{3}^{\prime},v_{4}^{\prime}\dots v_{k}^{\prime}\}$ be the set of vertices adjacent to $u$ that lie on these shortest paths. Thus $lk$ is the upper bound of the number of paths between $u$ and $v$. Since $(l+k)\leq(n-2)$, then $lk=O(n^{2})$.

Let $d_{i}$ be the degree of $v_{i}$ relative to the vertices $\{v_{1}^{\prime},v_{2}^{\prime},v_{3}^{\prime},v_{4}^{\prime}\dots v_{k}^{\prime}\}$, for $i=1,\dots,l$. Then the number of pairs of edge-disjoint paths between $u$ and $v$ is given by $PathCount=\sum_{i\neq j}d_{i}d_{j}$. Let $\sum d_{i}=t$. Now it follows from the equality $2l\sum d_{i}d_{j}=(l-1)(\sum d_{i})^{2}-\sum_{i\neq j}(d_{i}-d_{j})^{2}$ that $PathCount$ is maximum when all $d_{i}$’s are equal. Therefore an upperbound on $PathCount$ is $l^{2}.\frac{t}{l}=lt$. Since $t=O(lk)$, we have $PathCount=O(l^{2}k)$.