The Complexity of Subtree Intersection Representation of Chordal Graphs and Linear Time Chordal Graph Generation

TL;DR

This paper analyzes the complexity of subtree intersection representations of chordal graphs, corrects previous misconceptions about their size, and introduces a linear-time algorithm for generating large random chordal graphs.

Contribution

It establishes the sum of subtree sizes as 8 m8 8 n, shows contraction-minimal representations suffice, and presents the first linear-time generator for large chordal graphs.

Findings

Sum of subtree sizes is 8 m8 8 n

Contraction-minimal representations are sufficient

Generated graphs are large, diverse, and quickly produced

Abstract

It is known that any chordal graph on $n$ vertices can be represented as the intersection of $n$ subtrees in a tree on $n$ nodes. This fact is recently used in [2] to generate random chordal graphs on $n$ vertices by generating $n$ subtrees of a tree on $n$ nodes. It follows that the space (and thus time) complexity of such an algorithm is at least the sum of the sizes of the generated subtrees assuming that a tree is given by a set of nodes. In [2], this complexity was mistakenly claimed to be linear in the number $m$ of edges of the generated chordal graph. This error is corrected in [3] where the space complexity is shown to be $\Omega(m n^{1/4})$. The exact complexity of the algorithm is left as an open question. In this paper, we show that the sum of the sizes of $n$ subtrees in a tree on $n$ nodes is $\Theta(m\sqrt{n})$. We also show that we can confine ourselves to contraction-minimal subtree intersection representations since they are sufficient to generate every chordal graph. Furthermore, the sum of the sizes of the subtrees in such a representation is at most $2m+n$. We use this result to derive the first linear time random chordal graph generator. Based on contraction-minimal representations, we also derive structural properties of chordal graphs related to their connectivity. In addition to these theoretical results, we conduct experiments to study the quality of the chordal graphs generated by our algorithm and compare them to those in the literature. Our experimental study indicates that the generated graphs do not have a restricted structure and the sizes of maximal cliques are distributed fairly over the range. Furthermore, our algorithm is simple to implement and produces graphs with 10000 vertices and $4 . 10^7$ edges in less than one second on a laptop computer.

Figures

Tables

Table 1. Table 1: Experimental results of algorithm GenerateContractionMinimal

$𝒏$	Density	# conn. comp.s	# maximal cliques	Min clique size	Max clique size	Avg clique size	Sd of clique sizes	Time to build
1000	0.010	24.6	422.2	1.0	17.2	5.8	2.9	0.002
	0.100	1.0	62.8	7.3	125.0	43.3	26.8	0.003
	0.500	1.0	9.5	92.5	520.0	255.7	127.1	0.008
	0.780	1.0	6.5	167.2	767.4	393.1	201.0	0.010
2500	0.010	6.3	582.8	1.1	38.8	12.1	6.7	0.005
	0.100	1.0	70.7	12.4	311.9	101.4	65.8	0.010
	0.507	1.0	10.0	227.5	1357.7	617.6	330.4	0.030
	0.808	1.0	7.2	379.9	1997.9	931.1	535.3	0.049
5000	0.010	1.7	703.6	1.8	75.7	21.8	12.9	0.014
	0.102	1.0	78.5	22.7	635.1	196.1	131.0	0.035
	0.503	1.0	9.7	457.6	2479.1	1236.1	636.2	0.166
	0.796	1.0	7.2	775.5	3986.7	1914.0	1058.4	0.204
10000	0.010	1.4	825.0	2.8	146.4	40.4	25.3	0.036
	0.100	1.0	90.0	32.0	1385.9	356.9	266.5	0.132
	0.499	1.0	9.9	829.4	5343.8	2407.2	1366.3	0.659
	0.797	1.0	9.2	902.7	8125.6	3065.4	2243.1	0.952

Equations

$$t_t=\max \left\{t_j|j\in [t]\right\}$$

$$\forall j\in [t]s_j$$

$$\sum _{j=1}^t{s}_j$$

$$s_j\le t_j$$

$$2\sum _{j=1}^t{s}_j{t}_j-\sum _{j=1}^t{s}_j^2$$

$$2\sum _{j=1}^t{s}_j{t}_j-\sum _{j=1}^t{s}_j^2=\sum _{j=1}^t(2e_j+s_j)=2m+n.$$

$$\sum _{i=1}^n\left|V(T_i)\right|\le 2m+n.$$

$$\sum _{j=1}^t{t}_j\le \sum _{j=1}^t{s}_j{t}_j\le 2\sum _{j=1}^t{s}_j{t}_j-\sum _{j=1}^t{s}_j^2=2m+n$$

$$\sum _{i=1}^n\left|L(T_i^{\prime })\right|\text{ is }\Omega (m\sqrt{n}).$$

$$\sum _{i=1}^n\left|L(T_i^{\prime })\right|\ge 3^{k+1}\cdot (2\cdot 3^{2k}-1)+4\cdot 3^{2k}+2\cdot 3^{2k}-3^{k+1}\ge 6\cdot 3^{3k}.$$

$$\frac{{\sum }_{i=1}^n\left|L(T_i^{\prime })\right|}{m}\ge \frac{6\cdot 3^{3k}}{\frac{13}{2}\cdot 3^{2k}-\frac{3}{2}{3}^k}=\Omega (3^k)=\Omega (\sqrt{n}).$$

$$\forall j\in [t]k_j\ge 1$$

$$\sum _{j=1}^t{k}_j=n.$$

$$\sum _{i=1}^n\left|V(T_i^{\prime })\right|\le \sum _{j=1}^t{k}_j{t}_j.$$

$$k_v{t}_v=(k_j+k_{j^{\prime }})t_v\ge k_j{t}_j+k_{j^{\prime }}{t}_{j^{\prime }}.$$

$$\rho \stackrel{def}{=}\frac{{\sum }_{j=1}^t{k}_j{t}_j}{2m+n}\text{ is }\mathcal{O}(\sqrt{n}).$$

$$k_{j}=\left\{\begin{array}[]{ll}n-t+1&\textrm{~{}if~{}}j=t\\ 1&\textrm{otherwise}.\end{array}\right.$$

$$s_j{t}_j^{\prime }+s_{\ell }{t}_{\ell }^{\prime }=s_j(t_j-ϵ\frac{s_{\ell }}{s_j})+s_{\ell }(t_{\ell }+ϵ)=s_j{t}_j+s_{\ell }{t}_{\ell }.$$

$$k_j{t}_j^{\prime }+k_{\ell }{t}_{\ell }^{\prime }=k_j(t_j-ϵ\frac{s_{\ell }}{s_j})+k_{\ell }(t_{\ell }+ϵ)=k_j{t}_j+k_{\ell }{t}_{\ell }+ϵs_{\ell }({\lambda }_{\ell }-{\lambda }_j)\ge k_j{t}_j+k_{\ell }{t}_{\ell },$$

$$\sum _{j=1}^t{k}_j{t}_j$$

$$2m+n$$

$$(t-1)(n+(n-t+1)s_t)<t(2n-t)s_t.$$

$$\rho <\frac{n+(n-t+1)s_t}{\frac{(n-s_t{)}^2}{t-1}+s_t^2}=\frac{(t-1)(n+(n-t+1)s_t)}{(n-s_t{)}^2+(t-1)s_t^2}<\frac{t(2n-t)s_t}{n^2-2n{s}_t+t{s}_t^2}=\bar{\rho }(s_t).$$

$$\rho$$

$$\overline{\stackrel{ˉ}{\rho }}(t)=\frac{2u(2n-u^2)}{n}=4u-\frac{2u^3}{n}$$

$$\frac{\partial \overline{\stackrel{ˉ}{\rho }}}{\partial u}=4-\frac{6u^2}{n}.$$

$$\overline{\stackrel{ˉ}{\rho }}(t)\le \overline{\stackrel{ˉ}{\rho }}(2n/3)=4\sqrt{\frac{2n}{3}}-\frac{2}{n}\cdot \frac{2n}{3}\sqrt{\frac{2n}{3}}=\frac{8}{3}\sqrt{\frac{2n}{3}}.$$

$$\sum _{i=1}^n\left|V(T_i^{\prime })\right|\text{ is }\Theta (m\sqrt{n}).$$

Full text

In this paper, we show that the sum of the sizes of $n$ subtrees in a tree on $n$ nodes is $\Theta(m\sqrt{n})$. We also show that we can confine ourselves to contraction-minimal subtree intersection representations since they are sufficient to generate every chordal graph. Furthermore, the sum of the sizes of the subtrees in such a representation is at most $2m+n$. We use this result to derive the first linear time random chordal graph generator. Based on contraction-minimal representations, we also derive structural properties of chordal graphs related to their connectivity. In addition to these theoretical results, we conduct experiments to study the quality of the chordal graphs generated by our algorithm and compare them to those in the literature. Our experimental study indicates that the generated graphs do not have a restricted structure and the sizes of maximal cliques are distributed fairly over the range. Furthermore, our algorithm is simple to implement and produces graphs with 10000 vertices and $4.10^{7}$ edges in less than one second on a laptop computer.

Keywords: Chordal graph, Representation Complexity, Graph Generation.

1 Introduction

Chordal graphs are extensively studied in the literature from various aspects which are motivated by both theoretical and practical reasons. Chordal graphs have many application areas such as sparse matrix computations, database management, perfect phylogeny, VLSI, computer vision, knowledge based systems, and Bayesian networks (see e.g. [6, 9, 10, 12]). Consequently, numerous exact / heuristic / parameterized algorithms have been developed for various optimization and enumeration problems on chordal graphs. The need for testing and comparing these algorithms motivated researchers to generate random chordal graphs [8, 11, 1]. A more systematic study of random chordal graph generators has been initiated more recently in [2, 3]. The generic method developed in these papers is based on the characterization of chordal graphs as the intersection graph of subtrees of a tree [5], to which we will refer as a subtree intersection representation. In this method a chordal graph on $n$ vertices and $m$ edges is generated in three steps:

Generate a tree $T$ on $n$ nodes uniformly at random. 2. 2.

Generate $n$ non-empty subtrees $\left\{T_{1},\ldots,T_{n}\right\}$ of $T$. 3. 3.

Return the intersection graph $G$ of $\left\{V(T_{1}),\ldots,V(T_{n})\right\}$.

Three methods for generating subtrees in Step 2 have been suggested. In all these methods, every node of every subtree is generated. Steps 1 and 3 being linear in the size of $G$, the time and space complexities of the algorithm are dominated by the sum of the sizes of the subtrees generated at Step 2 which is $\sum_{i=1}^{n}\left|V(T_{i})\right|$. In [2], this complexity was mistakenly claimed to be linear in the size of $G$, that is $O(n+m)$. In [3], this mistake is corrected by showing that $\sum_{i=1}^{n}\left|V(T_{i})\right|$ is $\Omega(mn^{1/4})$, leaving the upper bound as an open question. This question is crucial for the complexity of any chordal graph generator that produces every subtree intersection representation on a tree of $n$ nodes. In this paper, we investigate the complexity of subtree intersection representations of chordal graphs. We show that $\sum_{i=1}^{n}\left|V(T_{i})\right|$ is $\Theta(m\sqrt{n})$. In other words, we both improve the lower bound of $\Omega(mn^{1/4})$ given in [3] and provide a matching upper bound. On the other hand, we show that the size of a ”contraction-minimal” representation is linear, more precisely, at most $2m+n$. This result plays the key role in developing a linear time chordal graph generator, the first algorithm in the literature having this time complexity, to the best of our knowledge. Our algorithm is also simple to implement. Our experiments indicate that it produces graphs for which the maximal clique sizes are distributed fairly over the range. Furthermore, the running time of the algorithm clearly outperforms the existing ones: graphs with 10000 vertices and $4.10^{7}$ edges are generated in less than one second on a personal computer.

Contraction-minimal representations of chordal graphs are further exploited to exhibit structural properties of chordal graphs. In particular, we show that every minimal representation of a chordal graph $G$ is on a tree with $t$ nodes where $t$ is the number of maximal cliques of $G$. Subsequently, we derive from this result that the connectivity of a chordal graph is at most $n-t$. Using this result, we show that our chordal graph generator can guarantee $k$-connectivity also in linear time.

We proceed with definitions and preliminaries in Section 2. Then, for technical reasons, we first consider contraction-minimal representations in Section 3. We develop our linear time random chordal graph generator in Section 3.1. We study the variety of chordal graphs generated by this algorithm in Section 3.2; to this end, following the practice in similar studies in the literature, we analyze maximal cliques of the generated graphs. In Section 3.3, we analyze the links between contraction-minimal representations and the connectivity properties of chordal graphs they represent. We proceed with the complexity of arbitrary subtree intersection representations in Section 4. We conclude in Section 5 by suggesting further research.

2 Preliminaries

Graphs: We use standard terminology and notation for graphs, see for instance [4]. We denote by $[n]$ the set of positive integers not larger than $n$. Given a simple undirected graph $G$, we denote by $V(G)$ the set of vertices of $G$ and by $E(G)$ the set of the edges of $G$. We denote an edge between two vertices $u$ and $v$ as $uv$. We say that a) the edge $uv\in E(G)$ is incident to $u$ and $v$, b) $u$ and $v$ are the endpoints of $uv$, and c) $u$ and $v$ are adjacent to each other. We denote by ${G}_{/{e}}$ the graph obtained from $G$ by contracting the edge $e$. A chord of a cycle $C$ of a graph $G$ is an edge of $G$ that connects two vertices that are non-adjacent in $C$. A graph is chordal if it contains no induced cycles of length 4 or more. In other words, a graph is chordal if every cycle of length at least 4 contains a chord. A vertex $v$ of a graph $G$ is termed simplicial if the subgraph of $G$ induced by $v$ and its neighbors is a complete graph. A graph $G$ on $n$ vertices is said to have a perfect elimination order if there is an ordering $v_{1},\ldots,v_{n}$ of its vertices, such that $v_{i}$ is simplicial in the subgraph induced by the vertices $\left\{v_{i},\ldots,v_{n}\right\}$ for every $i\in[n]$. It is known that a graph is chordal if and only if it has a perfect elimination order [6].

Trees, subtrees and their intersection graphs: Let ${\cal T}=\left\{T_{1},\ldots,T_{n}\right\}$ be a set of subtrees of a tree $T$. Let $G=(V,E)$ be a graph over the vertex set $\left\{v_{1},\ldots,v_{n}\right\}$ where $v_{i}$ represents $T_{i}$ and such that $v_{i}$ and $v_{j}$ are adjacent if and only if $T_{i}$ and $T_{j}$ have a common node. Then, $G$ is termed as the vertex-intersection graph of $\left<T,{\cal T}\right>$ and conversely $\left<T,{\cal T}\right>$ is termed a subtree intersection representation, or simply a representation of $G$. We will denote the intersection graph of $\left<T,{\cal T}\right>$ simply as $G({\cal T})$. Gavril [5] showed that a graph is chordal if and only if it is the vertex-intersection graph of subtrees of a tree. Throughout this work, we refer to the vertices of $T$ as nodes to avoid possible confusion with the vertices of $G({\cal T})$.

Let $G$ be a chordal graph with a representation $\left<T,{\cal T}\right>$, and $j$ be a node of $T$. We denote as ${\cal T}_{j}$ the set of subtrees in ${\cal T}$ that contain the node $j$, i.e. ${\cal T}_{j}\stackrel{{\scriptstyle def}}{{=}}\left\{T_{i}\in{\cal T}|j\in V(T_{i})\right\}$. Clearly, the set ${\cal T}_{j}$ corresponds to a clique of $G$ that we will denote $V_{j}$. It is also known that, conversely, if $K$ is a maximal clique of $G$ then $K=V_{j}$ for some node $j$ of $T$.

Two sets of subtrees ${\cal T}$ and ${\cal T}^{\prime}$ are equivalent if $G({\cal T})=G({\cal T}^{\prime})$. Let ${\cal T}$ be a set of subtrees of a tree $T$ and $e$ an edge of $T$. We denote by ${{\cal T}}_{/{e}}$ the set of subtrees of ${T}_{/{e}}$ that is obtained by contracting the edge $e$ of every subtree in ${\cal T}$ that contains $e$. A set of subtrees is contraction-minimal (or simply minimal) if for every edge $e$ of $T$ we have $G({{\cal T}}_{/{e}})\neq G({\cal T})$.

Throughout the rest of this work, $G$ is a chordal graph with vertex set $[n]$ and $m$ edges, $T$ is a tree on $t\leq n$ nodes and ${\cal T}=\left\{T_{1},\ldots,T_{n}\right\}$ is a set of subtrees of $T$ such that $G({\cal T})=G$ and $\left<T,{\cal T}\right>$ is contraction-minimal. We will adopt index $i\in[n]$ for vertices of $G$ and subtrees in ${\cal T}$ whereas index $j\in[t]$ is used to denote the nodes of $T$. We also denote by $t_{j}\stackrel{{\scriptstyle def}}{{=}}\left|{\cal T}_{j}\right|$ the number of subtrees in ${\cal T}$ that contain the node $j$ of $T$. The nodes of $T$ are numbered such that

[TABLE]

and all the other vertices are numbered according to a bottom-up order of $T$ where $t$ is the root.

In what follows, we first analyze contraction-minimal representations, then proceed into the analysis of the general case.

3 Contraction-minimal Representations

We first show in Section 3.1 that the size of a contraction-minimal representation is at most $2m+n$. Based on this result, we derive a linear time algorithm to generate random chordal graphs. In Section 3.2, we conduct experiments to compare chordal graphs obtained by our algorithm to those in the literature. Our experimental study indicates that our method is faster than existing methods in the literature. Our algorithm produces graphs with 10000 vertices and $4.10^{7}$ edges in less than one second on a personal computer. In addition, the generated graphs do not have a restricted structure as far as the size of their maximal cliques are concerned. In Section 3.3, we first show that minimal representations are exactly those representations of chordal graphs on a so-called clique tree of it. Subsequently, we analyze the links between contraction-minimal representations and the connectivity of the corresponding chordal graphs. We show that the connectivity of a chordal graph is at most $n-t$ and derive from this result a modification of our random chordal graph generator which ensures $k$-connectivity of the produced chordal graph also in linear time.

3.1 Chordal Graph Generation in Linear Time

The following observation plays an important role in our proofs as well as in our chordal graph generation algorithm.

Observation 1

$\left<T,{\cal T}\right>$* is minimal if and only if for every edge $jj^{\prime}$ of $T$, none of ${\cal T}_{j}$ and ${\cal T}_{j^{\prime}}$ contains the other (i.e., both ${\cal T}_{j}\setminus{\cal T}_{j^{\prime}}$ and ${\cal T}_{j^{\prime}}\setminus{\cal T}_{j}$ are non-empty).*

Proof: Suppose that ${\cal T}_{j}\subseteq{\cal T}_{j^{\prime}}$ for some edge $jj^{\prime}$ of $T$ and let $v$ be the node obtained by the contraction of the edge $jj^{\prime}$. Then every pair of subtrees that intersect on $j$ also intersect on $j^{\prime}$. Thus, they intersect also on $v$ (after the contraction of $jj^{\prime}$). Conversely, every pair of subtrees that intersect on $v$ contains at least one of $j,j^{\prime}$. By our assumption, they contain $j^{\prime}$, thus they intersect on $j^{\prime}$. Therefore, a pair of subtrees intersect in ${\cal T}$ if and only if they intersect in ${{\cal T}}_{/{jj^{\prime}}}$. Therefore, $G({{\cal T}}_{/{jj^{\prime}}})=G({\cal T})$, thus $\left<T,{\cal T}\right>$ is not contraction-minimal.

Now suppose that ${\cal T}_{j}^{\prime}\setminus{\cal T}_{j}\neq\emptyset$ and ${\cal T}_{j}\setminus{\cal T}_{j}^{\prime}\neq\emptyset$ for every edge $jj^{\prime}$ of $T$. Then, for every edge $jj^{\prime}$ of $T$ there exists a subtree that contains $j$ but not $j^{\prime}$ and another subtree that contains $j^{\prime}$ but not $j$. These two subtrees do not intersect, but they intersect on $v$ after the contraction of $jj^{\prime}$. Therefore, $G({{\cal T}}_{/{jj^{\prime}}})\neq G({\cal T})$ for every edge $jj^{\prime}$ of $T$. We conclude that $\left<T,{\cal T}\right>$ is contraction-minimal. $\square$

Lemma 1

Let $\left<T,{\cal T}\right>$ be a minimal representation of some chordal graph $G$ on $n$ vertices and $m$ edges. There exist numbers $s_{1},\ldots,s_{t}$ such that

[TABLE]

Proof: Consider the following pruning procedure of $T$ that implies a perfect elimination order for $G$. We first remove the leaf $j=1$ from $T$ and all the simplicial vertices of $G$ which are represented by the subtrees $T_{i}\in{\cal T}$ that consist of the leaf $j=1$. There is at least one such subtree by Observation 1. We continue in this way for every $j\in[t]$ until both $T$ and $G$ vanish. Let $G^{j}$ be the remaining graph at step $j$ before node $j$ is removed, and $s_{j}$ be the number of simplicial vertices of $G^{j}$ eliminated with the removal of node $j$. Clearly, the numbers $s_{j}$ satisfy relations (1) and (2). Recall that $t_{j}=\left|{\cal T}_{j}\right|$. To see that (3) holds, observe that the number of subtrees removed at step $j$ is at most the number of subtrees containing node $j$. Observe also that $t_{j}\leq n-\sum_{i=1}^{j-1}s_{i}$ as the subtrees eliminated at prior steps do not contain the node $j$ by the choice of the nodes to be removed at every step.

To show (4), let $e_{j}$ be the number of edges of $G$ that have been eliminated at phase $j$ of the pruning procedure (during which node $j$ of ${\cal T}$ is removed). We recall that a clique of $s_{j}$ vertices is removed, each vertex of which is adjacent to $t_{j}-s_{j}$ other vertices of $G$. Therefore, $e_{j}=s_{j}(s_{j}-1)/2+s_{j}(t_{j}-s_{j})$, i.e., $2e_{j}+s_{j}=2s_{j}t_{j}-s_{j}^{2}$. Summing up over all $j\in[t]$ we get

[TABLE]

$\square$ We are now ready to prove the main result of this section.

Theorem 1

If $\left<T,{\cal T}\right>$ is a minimal representation of some chordal graph $G$ on $n$ vertices and $m$ edges then

[TABLE]

Proof: We first note that $\sum_{i=1}^{n}\left|V(T_{i})\right|=\sum_{j=1}^{t}t_{j}$ since every node of every subtree $T_{i}$ contributes one to both sides of the equation. We conclude as follows using Lemma 1:

[TABLE]

where the first inequality and the last equality hold by relations (1) and (4) of Lemma 1 and the second inequality is obtained by replacing $t_{j}$ with $t_{j}+(t_{j}-s_{j})$ and noting that $t_{j}-s_{j}\geq 0$. $\square$

We now present algorithm GenerateContractionMinimal that generates a random contraction-minimal representation together with the corresponding chordal graph where every contraction-minimal representation has a positive probability to be returned. It creates a tree $T$ at random by starting from a single node and every time adding a leaf $j^{\prime}$ adjacent to some existing node $j$ that is chosen uniformly at random. Every time a node $j^{\prime}$ is added, the algorithm performs the following: a) a non-empty set of subtrees consisting of only $j^{\prime}$ is added to ${\cal T}$, b) a proper subset of the subtrees in ${\cal T}_{j}$ (i.e., those containing $j$) is chosen at random and every subtree of it is extended by adding the node $j^{\prime}$ and the edge $jj^{\prime}$, c) the graph $G$ is extended to reflect the changes in ${\cal T}$. A pseudo code of the algorithm is given in Algorithm 1.

Theorem 2

Algorithm GenerateContractionMinimal generates a chordal graph in linear time. Moreover, it generates any chordal graph on $n$ vertices with strictly positive probability.

Proof: The algorithm creates the tree $T$ incrementally, and the subtrees of ${\cal T}$ are created and extended together with $T$. More precisely, the set of subtrees containing a node of $T$ is not altered after a newer node is created. Note that, however, the subtrees themselves might be altered to contain newer nodes. Consider an edge $jj^{\prime}$ of $T$ where $j^{\prime}$ is newer than $j$. The sets ${\cal T}_{j}$ and ${\cal T}_{j^{\prime}}$ of the subtrees containing $j$ and $j^{\prime}$ respectively, are established by the end of the iteration that creates $j^{\prime}$. Since only a proper subset of ${\cal T}_{j}$ is chosen to be extended to $j^{\prime}$, at least one subtree in ${\cal T}_{j}$ does not contain $j^{\prime}$. Furthermore, since $j^{\prime}$ is created with a non-empty set of subtrees containing it, and none of these subtrees may contain $j$, there is at least one subtree in ${\cal T}_{j^{\prime}}$ that does not contain $j$. Therefore, by Observation 1, we conclude that $\left<T,{\cal T}\right>$ is contraction-minimal.

We proceed with the running time of the algorithm. It is well known that the addition of a single node and the addition of a single edge to a graph can be done in constant time. We observe that the number of operations performed by NewNode is $k+\binom{k}{2}=\left|V_{j^{\prime}}\right|+\left|E(V_{j^{\prime}})\right|$. Therefore, the number of operations performed in all invocations of NewNode is $n+\sum_{j^{\prime}\in V(T)}\left|E(V_{j^{\prime}})\right|$. Let $jj^{\prime}$ be the edge added to $T$ at some iteration of GenerateContractionMinimal. We now observe that the number of other operations (i.e., except the invocation of NewNode) performed during this iteration is exactly $\left|E(G)\cap(V_{j}\times V_{j^{\prime}})\right|$. We conclude that the number of operations of the algorithm is proportional to $n+\left|E(G)\right|$.

Consider a contraction-minimal representation $\left<\bar{T},\bar{{\cal T}}\right>$ with $\left|\bar{{\cal T}}\right|=n$ and let $\bar{t}=\left|\bar{T}\right|$. It remains to show that the algorithm returns $\left<\bar{T},\bar{{\cal T}}\right>$ with a positive probability.

We show by induction on $h$, that at the beginning of iteration $h$ (the $h$’th time the algorithm executes Line 8) $\left<T,{\cal T}\right>$ is a sub-representation of $\left<\bar{T},\bar{{\cal T}}\right>$ with positive probability. That is, $T$ is a subtree of $\bar{T}$ and ${\cal T}$ consists of the non-empty intersections of the subtrees of $\bar{{\cal T}}$ with $T$ (formally, ${\cal T}=\left\{\bar{T}_{i}[V(T)]~{}|~{}\bar{T}_{i}\in\bar{{\cal T}}\right\}\setminus\left\{(\emptyset,\emptyset)\right\}$) with positive probability. Let $\bar{j^{\prime}}$ be a node of $\bar{T}$, and let $\bar{k}=\left|\bar{{\cal T}}_{\bar{j^{\prime}}}\right|$. Clearly, $\bar{k}\leq n$. With probability $1/n$ the algorithm will start by creating a node with $\bar{k}$ trivial subtrees in which case $\left<T,{\cal T}\right>$ is a sub-representation of $\left<\bar{T},\bar{{\cal T}}\right>$. Therefore, the claim holds for $h=1$. Now suppose that $\left<T,{\cal T}\right>$ is a sub-representation of $\left<\bar{T},\bar{{\cal T}}\right>$ at the beginning of iteration $h$ with probability $p>0$. If $T=\bar{T}$ then $\left<T,{\cal T}\right>=\left<\bar{T},\bar{{\cal T}}\right>$, thus $\left|{\cal T}\right|=\left|\bar{{\cal T}}\right|=n$ and the algorithm does not proceed to iteration $h$. Otherwise, $T$ is a proper subtree of $\bar{T}$, i.e. $\bar{T}$ contains an edge $jj^{\prime}$ with $j\in V(T)$ and $j^{\prime}\notin V(T)$. At iteration $h$, $j$ will be chosen with probability $1/\left|V(T)\right|\geq 1/n$ by the algorithm and the edge $jj^{\prime}$ will be added to $T$, ensuring that $T$ is a subtree of $\bar{T}$ with probability at least $p/n$ at the end of iteration $h$. The number $\bar{k}$ of subtrees in $\bar{{\cal T}}$ that contain $j^{\prime}$ but not $j$ is at most $n-\left|{\cal T}\right|$. Since $\left<\bar{T},\bar{{\cal T}}\right>$ is contraction-minimal, we have $\bar{k}\geq 1$. Therefore, $\bar{k}\in[n-\left|{\cal T}\right|]$ and the algorithm creates $\bar{k}$ trivial subtrees in $j^{\prime}$ with probability $1/(n-\left|{\cal T}\right|)>1/n$. Since $\left<\bar{T},\bar{{\cal T}}\right>$ is contraction-minimal, the set of subtrees in $\bar{{\cal T}}$ that contain both $j$ and $j^{\prime}$ is a proper subset of $\bar{{\cal T}}_{j}={\cal T}_{j}$. The algorithm chooses this proper subset with probability $1/(2^{\left|{\cal T}_{j}\right|}-1)$ and adds the edge $jj^{\prime}$ to each of them. We conclude that at the end of iteration $h$ (thus at the beginning of iteration $h+1$), $\left<T,{\cal T}\right>$ is a sub-representation of $\left<\bar{T},\bar{{\cal T}}\right>$ with probability at least $p/(n^{2}2^{n})>0$. $\square$

3.2 Experimental studies

In this section, we present our experimental results to demonstrate the computational efficiency of GenerateContractionMinimal and to provide some insight into the distribution of chordal graphs it generates. We implemented the presented algorithm in C++, and executed it on a laptop computer with 2.00-GHz Intel Core i7 CPU. The implementation of the algorithm spans only 70 lines of C++ code. Our source code is available in

http://github.com/cmshalom/ChordalGraphGeneration.

Following the approach of works [11, 2, 3], we consider the characteristics of the maximal cliques of the returned graph. Table 1 provides a summary of the computational results of our algorithm. The first column reports the number of vertices $n$. For every value of $n$, we use four different average edge density values of 0.01, 0.1, 0.5, and 0.8, where edge density is defined as $\rho=\frac{m}{n(n-1)/2}$ with $m$ being the number of edges in the graph. For each pair of values $n,\rho$, we performed ten independent runs and reported the average values across those ten runs. The table exhibits the number of connected components, the number of maximal cliques, and the minimum, maximum, and average size of the maximal cliques along with their standard deviation. The rightmost column shows the time in seconds that it takes the algorithm takes to construct one graph. In order to achieve the desired edge density values, we discarded the graphs that turned out to be outside the range $[(1-\epsilon)\rho,(1+\epsilon)\rho]$, for $\epsilon=0.05$. For $\rho\leq 0.1$, we adjusted the upper bound at Line 17 in function NewNode so that graphs with small edge densities are obtained more probably.

Algorithm GenerateContractionMinimal produces connected chordal graphs for $\rho\geq 0.1$. When the average edge density is 0.01, the average number of connected components decreases as $n$ increases. A minimum clique size of 1 for $\rho=0.01$ and $n=1000$ implies that the disconnectedness of the graphs is due to the existence of isolated vertices. As for the running time of the algorithm, the linear time complexity shown in Theorem 2 clearly manifests itself in the amount of time it takes to construct a chordal graph. The rightmost column of Table 1 shows that our algorithm constructs a chordal graph in less than one second on average, even when $n=10000$ and $\rho=0.797$, i.e., $m>4\cdot 10^{7}$.

We compare our results to those of the two other methods from the literature. The first one is algorithm ChordalGen proposed in Şeker et al.’s work [3], which is based on the subtree intersection representation of chordal graphs. This algorithm is presented along with three alternative subtree generation methods. Here, we only consider algorithm ChordalGen together with the subtree generation method called GrowingSubtree, because this one is claimed to stand out as compared to the other presented methods, as far as the distribution of maximal clique sizes are concerned. The second algorithm we compare to is Andreou et al.’s algorithm [1]. This algorithm is also used in [3] for comparison purposes, and we refer to the implementation therein. In order to obtain results comparable to those given in [3], we use the same $n,\rho$ value pairs in our experiments.

We now compare the results in Table 1 to those reported in [3] for algorithm ChordalGen with GrowingSubtree and Andreou et al.’s algorithm. We observe that the number of maximal cliques of the graphs produced by GenerateContractionMinimal is usually lower than the others, and inevitably, their average clique sizes are higher than the others. The most notable difference of our algorithm from the others is its running time. Whereas a running time analysis of Andreou et al.’s algorithm has not been given in [1], the average running time of our implementation of their algorithm is of 477.1 seconds per generated graph, excluding graphs on 10000 vertices for which the algorithm was extremely slow. The average running times of our implementation of algorithm ChordalGen is 93.2, 4.7, 182.6 seconds with the subtree generation methods GrowingSubtree, ConnectingNodes, and PrunedTree, respectively. Algorithm GenerateContractionMinimal, however, achieves an average running time of 0.14 seconds.

In our next set of experimental results, we investigate the distribution of the sizes of maximal cliques to get some visual insight into the structure of the chordal graphs produced. Figure 1 shows the average number of maximal cliques across ten independent runs for $n=1000$ vertices and four edge density values. The figure is comprised of three rows, each row describing the result of the experiments on one algorithm; algorithms GenerateContractionMinimal, ChordalGen combined with GrowingSubtree method, and the implementation of Andreou et al.’s algorithm [1] as given in [3]. Every row consists of four histograms corresponding to four different average edge density values $\rho=0.01,0.1,0.5$, and $0.8$. The bin width of the histograms is taken as five; that is, frequencies of maximal clique sizes are summed over intervals of width five (from one to five, six to ten, etc.) and divided by the number of runs (i.e., ten) to obtain the average values. For a given $n$ and average edge density value, we keep the ranges of $x$-axes the same in order to make the histograms comparable. The $y$-axes, however, have different ranges because maximum frequencies in histograms vary considerably.

The histograms in Figure 1(a) reveal that the sizes of maximal cliques of graphs produced by our algorithm are not clustered around specific values; they are distributed fairly over the range. The shapes of the histograms for average edge densities 0.01 and 0.1 are similar for our algorithm and algorithm ChordalGen, as we observe from the first half of Figure 1(a) and 1(b). For higher densities (as we proceed to the right), the sizes of maximal cliques are distributed more uniformly in the graphs generated by our algorithm; there is no obvious mode of the distribution. In the graphs produced by Andreou et al.’s method, the vast majority of maximal cliques have up to 15 vertices when the average edge densities are 0.01 and 0.1. As we increase the edge density, frequencies of large-size maximal cliques become noticeable relative to the dominant frequencies of small-size maximal cliques. In any case, the range outside its extremes is barely used.

For brevity, we do not present the histograms for every $n$-value we consider in this study. Having presented the histograms for the smallest value of $n$ we consider, next we provide the set of results for a larger value of $n$. The implementation of Andreou et al.’s algorithm [1] turned out to be too slow to allow testing graphs on 10000 vertices in a reasonable amount of time. In order to present a complete comparison with the methods we look at from the literature, we provide the results for the next largest value of $n$ in Figure 2. From the histograms in Figure 2, we observe that the general distribution of maximal clique sizes do not change much with the increase in the number of vertices. Maximal clique sizes of chordal graphs produced by our algorithm are not confined to a limited area; they are distributed fairly over the range.

To summarize, our experiments show that GenerateContractionMinimal is by far faster than the existing methods in practice, in accordance with our theoretical bounds. Moreover, our inspection of the generated graphs in terms of their maximal cliques shows that the algorithm produces chordal graphs with no restricted structure.

3.3 Structural Consequences

By further analysis of contraction-minimal representations of chordal graphs, we show in this section that minimal representations are exactly those representations of chordal graphs on a so-called clique tree of it. Consequently, they provide us with important information about the connectivity properties of chordal graphs they represent.

Maximal cliques and clique trees: A clique tree of a chordal graph $G$ is a tree $T$ such that a) there is a bijection between the maximal cliques of $G$ and the nodes of $T$ and for every vertex $i\in V(G)$, the nodes of $T$ corresponding to maximal cliques of $G$ that contain $i$ form a subtree of $T$. It is well-known that a chordal graph on $n$ vertices has at most $n$ maximal cliques [6], thus every clique tree of it has at most $n$ nodes.

It turns out that there is a one-to-one correspondence between minimal representations of a chordal graph and its clique trees as shown in the following.

Proposition 1

$\left<T,{\cal T}\right>$* is a minimal representation of a chordal graph $G$ if and only if $T$ is a clique tree of $G$ and every vertex $i$ of $G$ is represented by the subtree $T_{i}$ of $T$ induced by the nodes representing the maximal cliques of $G$ containing $i$.*

Proof: Let $T$ be a clique tree of $G$ and ${\cal T}=\left\{T_{1},\ldots T_{n}\right\}$ where $T_{i}$ is the subtree of $T$ corresponding to the maximal cliques containing the vertex $i$ of $G$. We claim that $\left<T,{\cal T}\right>$ is a minimal representation of $G$. Indeed, consider an edge $e=jj^{\prime}$ of $T$. Since $j$ and $j^{\prime}$ correspond to distinct maximal cliques $V_{j}$ and $V_{j^{\prime}}$ of $G$, neither $V_{j}\setminus V_{j^{\prime}}$ nor $V_{j^{\prime}}\setminus V_{j}$ is empty. That is, there is a subtree in ${\cal T}$ that contains $j$ but does not contain $j^{\prime}$ and vice versa. By Observation 1, $\left<T,{\cal T}\right>$ is a minimal representation of $G$.

Let now $\left<T,{\cal T}\right>$ be a minimal representation of $G$. If $T$ consists of a single node, then $G$ is a complete graph and it has only one maximal clique that corresponds to the single node of $T$. Therefore, $T$ is a clique tree of $G$. Otherwise, let $e=jj^{\prime}$ be an edge of $T$. By Observation 1, neither ${\cal T}_{j}\setminus{\cal T}_{j^{\prime}}$ nor ${\cal T}_{j^{\prime}}\setminus{\cal T}_{j}$ is empty, i.e., neither $V_{j}\setminus V_{j^{\prime}}$ nor $V_{j^{\prime}}\setminus V_{j}$ is empty. Therefore both $V_{j}$ and $V_{j^{\prime}}$ are maximal cliques of $G$. Since $e$ is an arbitrary edge of $T$, we conclude that $V_{j}$ is a maximal clique of $G$ for every node $j$ of $T$. Let now $V_{j}$ and $V_{j^{\prime}}$ be two maximal cliques of $G$ corresponding to two (not necessarily adjacent) nodes $j$ and $j^{\prime}$ in $T$, where $j\neq j^{\prime}$. Let $j^{\prime\prime}$ be the node adjacent to $j$ on the path between $j$ and $j^{\prime}$ in $T$ (with possibly $j^{\prime\prime}=j^{\prime}$). By Observation 1, there is a subtree $T_{i}\in{\cal T}$ such that $T_{i}\in{\cal T}_{j}$ and $T_{i}\notin{\cal T}_{j^{\prime\prime}}$. Therefore, $T_{i}\notin{\cal T}_{j^{\prime}}$, thus $V_{j}\neq V_{j^{\prime}}$. We conclude that the maximal cliques corresponding to nodes of $T$ are distinct. Clearly, the subtree $T_{i}$ that represents a vertex $i$ of $G$ corresponds to the set of maximal cliques that contain $i$. Therefore, $T$ is a clique tree as claimed. $\square$

As the number of maximal cliques is a graph invariant, Proposition 1 implies that making any arbitrary representation of a chordal graph minimal by repetitively contracting edges always yields a minimal representation on a tree with the same number of nodes (which is the number of maximal cliques of $G$).

Corollary 1

Given a chordal graph $G$, every minimal representation $\left<T,{\cal T}\right>$ of $G$ has a tree $T$ on $t$ nodes where $t$ is the number of maximal cliques of $G$.

Separators and minimal separators: A set $S$ of vertices of a connected graph $G$ is called a separator if $G\setminus S$ is not connected where $G\setminus S$ denotes the graph induced by $V(G)\setminus S$. For two non adjacent vertices $i$ and $i^{\prime}$ of $G$, the set $S$ is an $i$-$i^{\prime}$ separator if $i$ and $i^{\prime}$ are in different connected components of $G\setminus S$. An $i$-$i^{\prime}$ separator is minimal if none of its proper subsets separates $i$ and $i^{\prime}$. We say that $S$ is a minimal separator of $G$ if there exists two non adjacent vertices $i$ and $i^{\prime}$ in $G$ such that $S$ is a minimal $i$-$i^{\prime}$ separator. A graph is $k$-connected if it has more than $k$ vertices and every separator of it has at least $k$ vertices. The (vertex) connectivity $\kappa(G)$ of $G$ is the largest number $k$ such that $G$ is $k$-connected. Given a representation $\left<T,{\cal T}\right>$ of a chordal graph $G$ and an edge $e$ of $T$, we denote by ${\cal T}_{e}$ the set of subtrees in ${\cal T}$ that contain $e$, and by $V_{e}$ the set of vertices of $G$ represented by them.

It is well-known that the minimal separators of a chordal graph are complete subgraphs [6]. The following result describes more precisely the minimal separators of a chordal graph by means of its clique trees.

Theorem 3

[7]** Given a chordal graph $G$ and any clique tree $T$ of $G$, a set of vertices $S$ is a minimal separator of $G$ if and only if $S=V_{e}$ for some edge $e$ of $T$.

Proposition 1 and Theorem 3 imply the following relation between minimal representations of a chordal graph and its minimal separators.

Corollary 2

Let $\left<T,{\cal T}\right>$ be a minimal representation of a chordal graph $G$ where $\left|V(T)\right|=t$. Then

1. i)

The set of minimal separators of $G$ is $\left\{V_{e}|e\in E(T)\right\}$. 2. ii)

The number of minimal separators of a chordal graph is at most $t-1$. 3. iii)

$\kappa(G)=\min\left\{\left|V_{e}\right||e\in E(T)\right\}$.

Proposition 2

Let $\left<T,{\cal T}\right>$ be a minimal representation of a chordal graph $G$ on $n$ vertices where $\left|V(T)\right|=t$. Then,

1. i)

For every edge $e$ of $T$, the number of subtrees in ${\cal T}$ that contain $e$ is at most $n-t$, 2. ii)

$\kappa(G)\leq n-t$.

Proof:

1. i)

Let $\left<T,{\cal T}\right>$ be a minimal representation of a chordal graph $G$ on $n$ vertices and $e=jj^{\prime}$ be an edge of $T$. We prove by induction on $t$. If $t=2$ then since $\left<T,{\cal T}\right>$ is contraction-minimal, there is at least one subtree in ${\cal T}_{j}$ that does not contain $jj^{\prime}$ and at least one subtree in ${\cal T}_{j^{\prime}}$ that does not contain $jj^{\prime}$, and we are done.

If $t>2$ at least one of $j,j^{\prime}$ is not a leaf of $T$. Therefore, $T$ contains at least one leaf $j^{\prime\prime}\notin\left\{j,j^{\prime}\right\}$. Let $T^{\prime}=T-j^{\prime\prime}$ and $\left<T^{\prime},{\cal T}^{\prime}\right>$ be the sub-representation of $\left<T,{\cal T}\right>$ where ${\cal T}^{\prime}$ consists of the non-empty intersections of the subtrees of ${\cal T}$ with $T^{\prime}$. Then $\left<T^{\prime},{\cal T}^{\prime}\right>$ is a minimal representation of $G[V^{\prime}]$ where $V^{\prime}$ is the set of vertices of $G$ represented by the subtrees in ${\cal T}^{\prime}$. By the induction hypothesis, ${\cal T}^{\prime}$ contains at least $\left|V(T^{\prime})\right|=t-1$ subtrees not containing $jj^{\prime}$. Furthermore, ${\cal T}$ contains at least one subtree $T_{i}$ that contains $j^{\prime\prime}$ but not its neighbour in $T$. Thus $T_{i}\in{\cal T}\setminus{\cal T}^{\prime}$ and it does not contain $jj^{\prime}$. Therefore, ${\cal T}$ contains at least $\left|V(T^{\prime})\right|+1=t$ subtrees that do not contain $jj^{\prime}$. We conclude that ${\cal T}$ contains at most $n-t$ subtrees that contain $e$. 2. ii)

We have $\left|V_{e}\right|=\left|{\cal T}_{e}\right|\leq n-t$. The result follows from Corollary 2.

$\square$

Corollary 3

With the following modifications, GenerateContractionMinimal generates $k$-connected chordal graphs in linear time.

1. i)

At line 11 where a proper subset to contain the edge $jj^{\prime}$ is chosen, pick a proper subset ${\cal T}^{\prime}$ of ${\cal T}_{j}$ of cardinality at least $k$. 2. ii)

At the first invocation of NewNode, create a clique of at least $k+1$ vertices.

Proof: By Corollary 2, the choice of a proper subset of cardinality at least $k$, i.e., the successful execution of (the modified) Line 11 at every node is necessary and sufficient for $k$-connectivity. Suppose that the execution of Line 11 fails at some node of $T$, and let $j$ be the first node that this happens. If $j$ is not the first node of $T$, let $j^{\prime\prime}$ be the node chosen by the algorithm when $j$ is created. Since Line 11 did not fail at $j^{\prime\prime}$, at least $k$ subtrees from ${\cal T}_{j^{\prime\prime}}$ contain $j^{\prime\prime}j$. Moreover, at least one more subtree is created by NewNode when $j$ is created. Therefore, ${\cal T}_{j}$ contains at least $k+1$ subtrees, and Line 11 does not fail at $j$, a contradiction. We conclude that $j$ must be the first node of $T$. Therefore, the second modification is sufficient to guarantee that the chordal graph generated by the algorithm is $k$-connected. Clearly, these modifications do not change the time complexity of GenerateContractionMinimal. $\square$

Noting that in a minimal representation $\left<T,{\cal T}\right>$ of a chordal graph $G$, a subtree of ${\cal T}$ containing an edge of $T$ yields an edge in $G$, Proposition 2 implies the following simple characterization of minimal representations of an independent set. Indeed, this can be viewed as a reformulation of the following well known fact in terms of minimal representations: A chordal graph $G$ on $n$ vertices has at most $n$ maximal cliques, with equality if and only if $G$ is an independent set [6].

Observation 2

Let $\left<T,{\cal T}\right>$ be a minimal representation of a chordal graph $G$ on $n$ vertices where $\left|V(T)\right|=t$. Then, $G$ is an independent set if and only if $t=n$.

Proposition 2 also gives some insight about minimal representations of special chordal graphs such as trees and forests as described in Propositions 3 and 4 respectively.

Proposition 3

Let $\left<T,{\cal T}\right>$ is a minimal representation of a connected chordal graph $G$ on $n\geq 2$ vertices where $\left|V(T)\right|=t$. Then, $G$ is a tree if and only if $t=n-1$.

Proof: Assume that $t=n-1$. Since $G$ is connected, it remains to show that $G$ does not contain cycles. Suppose that $G$ contains a cycle. Since $G$ is chordal, it must contain a triangle. Therefore, the clique number of $G$ is at least 3.

Consider an execution of GenerateContractionMinimal that generates the representation $\left<T,{\cal T}\right>$ and the graph $G=G({\cal T})$. Let ${\cal T}^{(j)}$ be the set of subtrees of ${\cal T}$ generated by the $j$-th invocation of NewNode (that created the node $j$ of $T$). Then $\left\{{\cal T}^{(1)},\ldots,{\cal T}^{(n-1)}\right\}$ is a partition of ${\cal T}$. Therefore, $\left|{\cal T}^{(j)}\right|=2$ for some $j\in[n-1]$ and $\left|{\cal T}^{(j^{\prime})}\right|=1$, for every $j^{\prime}\neq j$. Corollary 3 implies that $j=1$. By the behaviour of GenerateContractionMinimal, it is easy to show by induction on $j$, that, $\left|{\cal T}_{j}\right|=2$ for every $j\in[n-1]$. That is, every maximal clique of $G$ has exactly two vertices, i.e. the clique number of $G$ is at most 2, a contradiction.

Conversely, assume that $G$ is a tree on $n$ vertices. The set of maximal cliques of $G$ is the set of its $n-1$ edges. By Proposition 1, every minimal representation of $G$ has a tree $T$ on $t=n-1$ nodes. $\square$

We note that a minimal representation of a tree is not unique. For example, let $G$ be a star on $n$ vertices. For every tree $T$ on $n-1$ vertices, $G$ has a representation $\left<T,{\cal T}\right>$. Indeed, ${\cal T}$ consists of $T$ itself and the $n-1$ trivial subtrees of $T$.

If we relax the condition that $G$ is connected in Proposition 3, then we obtain the following result.

Proposition 4

1. i)

If $\left<T,{\cal T}\right>$ is a minimal representation of a chordal graph $G$ on $n$ vertices, and $\left|V(T)\right|=t=n-1$ then $G$ is a forest, where all the trees of $G$ except one are trivial. 2. ii)

Every forest on $n\geq 2$ vertices with exactly one non-trivial tree has a minimal representation $\left<T,{\cal T}\right>$ with $\left|V(T)\right|=t=n-1$.

Proof:

1. i)

By Proposition 2, every edge of $T$ is contained in at most one subtree in ${\cal T}$. Let $T^{(1)},\ldots,T^{(\ell)}$ be the subtrees of $T$ obtained by the removal of the edges $e$ such that ${\cal T}_{e}=\emptyset$, and $n_{i}$ be the number of subtrees in ${\cal T}$ that are contained in $T^{(i)}$ for every $i\in[\ell]$. Clearly, $\sum_{i=1}^{\ell}\left|V(T^{(i)})\right|=t=n-1$, $\sum_{i=1}^{\ell}n_{i}=n$, and $n_{i}\geq\left|V(T^{(i)})\right|$ for every $i\in\ell$. Therefore, there exists some $j\in[\ell]$ such that $n_{j}=\left|V(T^{(j)})\right|+1$, and $n_{j^{\prime}}=\left|V(T^{(j^{\prime})})\right|$ for every $j^{\prime}\in[\ell]$ different than $j$. By Proposition 3, the subtrees in $T^{(j)}$ represent a tree. By Observation 2, the subtrees in $T^{(j^{\prime})}$ represent an independent set for every $j^{\prime}\in[\ell]$ different than $j$. 2. ii)

Let $G$ be a forest on $n$ vertices, with exactly one non-trivial tree $G^{\prime}$ on $n^{\prime}$ vertices. Let $\left<T^{\prime},{\cal T}^{\prime}\right>$ be a representation of $G^{\prime}$ with $\left|T^{\prime}\right|=n^{\prime}-1$. By adding $n-n^{\prime}$ new nodes to $T^{\prime}$, and adding to ${\cal T}^{\prime}$ a trivial tree (consisting of that node) for every new node, we get a representation of $G$ on a tree with $n-1$ nodes.

$\square$

4 Arbitrary Representations

We start this section by showing that the upper bound of Theorem 1 does not hold for arbitrary representations on trees with $n$ nodes. We denote by $L(T)$ the set of leaves of a tree $T$.

Lemma 2

Let ${\cal T}^{\prime}=\left\{T^{\prime}_{1},\ldots,T^{\prime}_{n}\right\}$ be a set of subtrees on a tree with $n$ nodes and $m$ be the number of edges of $G({\cal T}^{\prime})$. Then

[TABLE]

Proof: Let $k$ be a non-negative integer, and $n=6\cdot 3^{2k}$. Let $T^{\prime}$ be a tree on $n$ nodes $\{v_{1},\ldots,v_{4\cdot 3^{2k}},u_{1},\ldots,u_{2\cdot 3^{2k}}\}$, where the nodes $\{v_{1},\ldots,v_{4\cdot 3^{2k}}\}$ induce a path and the nodes $\{u_{1},\ldots,u_{2\cdot 3^{2k}}\}$ induce a star with center $u_{1}$. The representation contains the following subtrees:

• •

$S_{1}$: 2 trivial paths on every node in $\{v_{1},\ldots,v_{2\cdot 3^{2k}}\}$, for a total of $4\cdot 3^{2k}$ paths,

• •

$S_{2}$: $3^{k+1}$ copies of the star on nodes $\{u_{1},\ldots,u_{2\cdot 3^{2k}}\}$, and

• •

$S_{3}$: $2\cdot 3^{2k}-3^{k+1}$ disjoint trivial paths on part of the nodes in $\{v_{2\cdot 3^{2k}+1},\ldots,v_{4\cdot 3^{2k}}\}$. Note that the number of these paths is less than the number $2\cdot 3^{2k}$ of nodes in the path, thus disjointness can be achieved.

The number of subtrees is $4\cdot 3^{2k}+3^{k+1}+2\cdot 3^{2k}-3^{k+1}=6\cdot 3^{2k}=n$, as required. As for the total number of leaves, we have:

[TABLE]

Let $G$ be the intersection graph of these subtrees. $G$ consists of a $K_{3^{k+1}}$, $2\cdot 3^{2k}$ disjoint $K_{2}$s and isolated vertices. We have $m=2\cdot 3^{2k}+3^{k+1}\frac{3^{k+1}-1}{2}$, thus

[TABLE]

$\square$

Since the space needed to represent a subtree is at least the number of its leaves, Lemma 2 implies the following:

Corollary 4

The time complexity of any algorithm that generates chordal graphs by picking an arbitrary subtree representation on a tree with $n$ nodes is $\Omega(m\sqrt{n})$.

We now proceed to show that this bound is tight up to a constant factor.

Through the rest of this section $T^{\prime}$ is a tree on $n$ nodes and ${\cal T}^{\prime}=\left\{T^{\prime}_{1},\ldots,T^{\prime}_{n}\right\}$ is a set of subtrees of $T^{\prime}$ such that $G({\cal T}^{\prime})=G$. We also denote by $t^{\prime}_{j}\stackrel{{\scriptstyle def}}{{=}}\left|{\cal T}^{\prime}_{j}\right|$ the number of subtrees in ${\cal T}^{\prime}$ that contain the node $j$ of $T^{\prime}$. We assume that $\left<T,{\cal T}\right>$ is a contraction-minimal representation of $G$ obtained from $\left<T^{\prime},{\cal T}^{\prime}\right>$ by zero or more successive contraction operations. Then, $T$ has $t\leq n$ nodes and the multiplicity of $j$ (with respect to $T^{\prime}$), denoted by $k_{j}$, is the number of contractions effectuated in $T^{\prime}$ in order to obtain node $j$ in $T$, plus one.

Lemma 3

With the above notations, we have

[TABLE]

Proof: Relations (5) and (6) hold by definition of $t$ and multiplicity.

When an edge $jj^{\prime}$ of $T^{\prime}$ is contracted to a node $v$ we have $k_{v}=k_{j}+k_{j^{\prime}}$ and $t_{v}=\max\left\{t_{j},t_{j^{\prime}}\right\}$. Therefore,

[TABLE]

Using the above fact and noting that we have $\sum_{i=1}^{n}\left|V(T^{\prime}_{i})\right|=\sum_{j=1}^{n}t^{\prime}_{j}$, inequality (7) follows by induction on the number of contractions. $\square$ Recall that our task is to find an upper bound on the sum of the sizes of subtrees in a representation on a tree with $n$ nodes of a chordal graph on $n$ vertices. Relation (7) allows us to focus on the sum of $k_{j}t_{j}$ values (in a minimal representation) in order to achieve this goal. In what follows, we treat this task as an optimization problem under a given set of constraints. Thus, the following lemma can be (and should be) read independently from graph theoretic interpretations of each parameter.

Lemma 4

Let $t$, $s_{1},\ldots,s_{t}$, $t_{1},\ldots t_{t}$ and $k_{1},\ldots,k_{t}$ be numbers that satisfy (1), (2), (3), (4), (5), and (6). Then

[TABLE]

Proof: Let $k_{j},s_{j},t_{j}(j\in[t])$ be values that maximize $\rho$ which we refer as optimal. Such values exist since $k_{j},t_{j}\leq n$, thus $\rho\leq\frac{n^{3}}{2m+n}$. Let also $\lambda_{j}=k_{j}/s_{j}$. If $t=1$ we have $k_{1}=s_{1}=t_{1}=n$. Then (4) implies $2m+n=n^{2}$, thus $\rho=1$. Therefore, in the rest of the proof we assume $t\geq 2$.

Since the only constraints for $k_{j}$ are (5) and (6), and $k_{j}$ does not appear in the denominator of $\rho$, there are optimal values where

[TABLE]

Therefore, we have $\lambda_{j}=\frac{1}{s_{j}}\leq 1$ for all $j\in[t-1]$. This implies $\lambda_{t}\geq 1$ since otherwise $n=\sum_{j=1}^{t}k_{j}=\sum_{j=1}^{t-1}k_{j}+k_{t}\leq\sum_{j=1}^{t-1}s_{j}+k_{t}<\sum_{j=1}^{t-1}s_{j}+s_{t}=n$, a contradiction.

By (3) we have $s_{t}\leq t_{t}=\sum_{i=t}^{t}s_{i}=s_{t}$, thus $t_{t}=s_{t}$. Furthermore, $t_{j}<\sum_{i=j}^{t}s_{i}$ for every $j<t$ since otherwise $t_{j}=\sum_{i=j}^{t}s_{i}>\sum_{i=t}^{t}s_{i}=t_{t}$, contradicting the maximality of $t_{t}$ (recall that $t_{t}=\max\{t_{j}|j\in[t]\}$). Also, $s_{t}=t_{t}\geq t_{j}\geq s_{j}$ for every $j\in[t]$. Let $\ell\in[t-1]$ be such that $s_{\ell}=\min_{j\in[t-1]}s_{j}$.

The following claim guarantees optimal values with an even more restricted structure.

Claim 1

There are optimal values with $s_{j}=t_{j}$ for every $j\in[t]$ different from $\ell$.

Proof: Consider optimal values minimizing $\sum_{j\neq\ell}t_{j}$ among all optimal values that satisfy relations (1) - (6) and where $k_{j}$s are defined as above. Assume by way of contradiction that these values do not satisfy the claim, i.e. there exists $j\neq\ell$ with $s_{j}<t_{j}$. Since $t_{t}=s_{t}$, we have $j\neq t$. By the choice of $\ell$ we have $\lambda_{j}\leq\lambda_{\ell}$, and recall that $t_{\ell}<\sum_{i=\ell}^{t}s_{i}$.

Let $t^{\prime}_{\ell}=t_{\ell}+\epsilon$ and $t^{\prime}_{j}=t_{j}-\epsilon\frac{s_{\ell}}{s_{j}}$ for some $\epsilon>0$. We have

[TABLE]

Therefore, if we replace $t_{j},t_{\ell}$ by $t^{\prime}_{j}$ and $t^{\prime}_{\ell}$ respectively, relation (4) remains valid. Moreover, we can choose $\epsilon$ sufficiently small so that all constraints (3) are still satisfied. As for the numerator of $\rho$, we have

[TABLE]

i.e. the values are optimal. However $\sum_{j\neq\ell}t_{j}$ decreased by $\epsilon\frac{s_{\ell}}{s_{j}}$, contradicting the way the optimal values were chosen. $\square$ We now note that $t_{\ell}\leq t_{t}=s_{t}=n-\sum_{j=1}^{t-1}s_{j}$. Therefore, we have

[TABLE]

where the last inequality holds because $\sum_{j=1}^{t-1}s_{j}=n-s_{t}$ and when the sum is fixed, the sum of squares is smallest when all numbers are equal. Now, we note that $0<2(n-t)+1$ and this is equivalent to $(t-1)n<t(2n-t)-(t-1)(n-t+1)$ which implies in turn the following inequality since $s_{t}\geq 1$:

[TABLE]

We combine inequalities (8), (9) and (10) as follows

[TABLE]

$\frac{\partial\bar{\rho}}{\partial s_{t}}\geq 0$ if and only if $n^{2}-2ns_{t}+ts_{t}^{2}\geq s_{t}(2ts_{t}-2n)$ if and only if $n^{2}\geq ts_{t}^{2}$. Therefore, $\bar{\rho}$ is maximum when $s_{t}=\frac{n}{\sqrt{t}}$. We conclude

[TABLE]

where we use the fact that $t\geq 2$ to derive the inequality. We substitute $u=\sqrt{t}$ to get

[TABLE]

and we derive

[TABLE]

Since $\frac{\partial u}{\partial t}>0$, $\bar{\bar{\rho}}$ attains its maximum at $t=u^{2}=\frac{2n}{3}$. We conclude

[TABLE]

$\square$

We can now infer the following theorem.

Theorem 4

Let $\left<T^{\prime},{\cal T}^{\prime}\right>$ be a representation of a chordal graph $G$ where $T^{\prime}$ has $n$ nodes and $G$ has $n$ vertices and $m$ edges. Then we have

[TABLE]

Proof: Let $\left<T,{\cal T}\right>$ be a minimal representation of $G$ obtained from $\left<T^{\prime},{\cal T}^{\prime}\right>$. Then $\left<T,{\cal T}\right>$ satisfies (1), (2), (3), (4) by Lemma 1, and (5), (6), (7) hold by Lemma 4. The lower and upper bounds provided in Lemmas 2 and 4 respectively allows us to conclude the proof. $\square$

5 Conclusion

In this work, we present a linear time algorithm to generate random chordal graphs. To the best of our knowledge, this is the first algorithm with this time complexity. Our algorithm is fast in practice and simple to implement. We also show that the complexity of any random chordal graph generator which produces any subtree intersection representation on a tree of $n$ nodes with positive probability is $\Omega(m\sqrt{n})$.

We conducted experiments to analyze the distribution of the sizes of the maximal cliques of the generated chordal graphs. As a result, we concluded that our method generates fairly varied chordal graphs with respect to this measure. It should be noted that, however, we do not know the distribution of the maximal clique sizes over the space of all chordal graphs of a given size.

We have shown that every chordal graph on $n$ vertices is returned by our algorithm with positive probability. Our algorithm allows us to analyze connectivity properties of the generated chordal graphs, and can be used to generate chordal graphs having a given (vertex) connectivity.

The development of an algorithm that generates chordal graphs uniformly at random is subject of further research.