Sampling Crossing-Free Spanning Trees

in Geometric Graphs

by

Sawan Kumar Jindal

Advisor:

Dr. Ivona Bezakova

Department of Computer Science

Contents

1: Introduction

2: Background

2.1 Geometric Graphs

2.2 Crossing-Free Tree

2.3 Spanning Tree

2.4 Markov Chain Principle

2.5 Coupon Collector Problem

2.6 Enumerating all crossing free spanning trees

3: Novel Algorithms

3.1 Crossing free Spanning Tree

3.1.1 Crossing- Free Verification

3.1.2 Spanning Tree Verification

3.2 Markov Chain Principle

3.2.1 Verification of Symmetric nature

3.2.2 Verification of reach-ability of all Spanning Trees

4: Algorithm Analysis

4.1 Flow Chart of the Algorithm

4.2 Algorithm Complexity Analysis

5: Setting up the environment

5.1 Input Type

5.2 Intermediate Results

6: Experimentation and Results

7: Conclusions

8: Future Work

9: References

Introduction

Spanning trees are one of the most important algorithms in theoretical science today. They can be

seen as path finding algorithms which minimizes the cost of power networks, wiring connections, piping,

automatic speech recognition, etc. In this project, we are analyzing geometric graphs and finding about

the spanning trees with a special property of crossing-free nature, in them. We are using randomized

Markov Chain algorithms to find out all the spanning trees.

In this project we are working with complete graphs and assuming that the points are in general

position (that is, there are no three or more collinear points). We are analyzing crossing-free spanning

trees in such graphs. In particular, we are aiming to generate a random crossing-free spanning tree, as

well as to count all such spanning trees for a given graph.

Crossing-free structures have been investigated by the computational geometry community for

decades. However, almost all of the developed (deterministic) algorithms counting these structures run

in exponential time. There are a lot of approaches for finding a crossing – free spanning tree. One simple

approach to find a crossing free spanning tree would be to take a vertex, and draw line segments from

that vertex to every other vertex in the graph. We are using another approach to generate crossing-free

spanning tree as it will help us better with our next steps. The proof of the crossing-free nature, the

spanning tree property and its authenticity are included in the later sections.

After generating crossing free spanning tree, we are experimenting with probabilistic Markov Chain

algorithms to see if we can achieve close approximation of the answer(generation of all crossing free

spanning trees) in polynomial time.

We have used this project to generate the crossing free spanning trees experimenting with a graph

containing 5 vertices and after successful execution; we are able to generate 77 crossing free spanning

trees. We tried 9200 Markov Chain steps per sample and after 378 numbers of iterations (coupon

collector value), we are able to reach all states.

In the next sections we will describe about the related background and how these algorithms fit into this

project. Furthermore, implementation details of the crossing free spanning tree and probabilistic

sampling algorithm and results using these algorithms are discussed.

Background

Theoretical science contains a lot of algorithms which better our day to day life. A big chunk of these

algorithms are graph algorithms. This project deals with a specific problem of figuring out all crossing

free spanning trees in geometric graphs using probabilistic randomized Markov Chain algorithm. These

are defined in detail below:

2.1 Geometric Graphs

Geometric graphs are defined by a set of points in the plane that form the vertices, and edges are

straight line segments connecting corresponding vertices. In other words, these are the graphs in which

the vertices are defined by a set of points(x,y) (which fixes their location). The straight line segments

joining any two vertices are called edges. Fig 1 is an example of a geometric graph.

Figure 1: Geometric graphs with different number of vertices

2.2 Crossing-Free Tree

Crossing free is a special property associated with spanning trees for this project to describe a special set

of applications such as Network Design problems. Crossing free trees are those trees in which no two

branches overlap one another. In other words, crossing free property states that no two edges of a

geometric graph cross each other.

a) Non-Crossing free tree b) Crossing free tree

2.3 Spanning Tree

Spanning trees are the trees that are the sub graphs with minimum number of edges from the graph

which connects all the vertices. For a graph containing n vertices, there are maximum of n^(n-2) number

of spanning trees.

a) Graph

b) Spanning Tree

2.4 Markov Chain Principle

Markov Chain Principle for state states that to move from the present state to the next state, there must

be some change which triggers the change of state [4]. These changes/moves of state are independent

on the previous moves and are called markov processes [3]. An example with two states is described in

the below figure.

Fig: Markov Chain Model [5]

2.5 Coupon Collector Problem

Coupon collector problem is a problem related to probability which states that if you have n samples

and you have to draw one sample at a time, with replacement, then in how many draws can you see all

the samples at least once of the draw[6]. The equation for this problem is:

2.6 Enumerating all crossing free spanning trees

This section of the paper discusses an approach to enumerate through all the crossing free spanning

trees of a geometric graph [7,8] without generating duplicates at any point during the process. It is a

unique approach as it uses divide and conquer technique to find all the spanning trees in a graph [1]. For

graphs, duplicate spanning trees are a big problem which is very necessary to deal with and requires a

lot of comparisons to remove.

The flow of the algorithm contains multiple steps which are as follows:

Selection of Reference Vertex and Removal of Pendant Edge:

For a given set of vertices and graph, we randomly choose a vertex and call it vref. This vref will be

the mode of operation for the whole algorithm. After choosing a reference vertex, we have to remove

any pendant edge associated with the reference vertex. Pendant edges are those edges which have two

vertices, reference vertex and one such vertex which doesn’t connect with any other vertex in a graph.

The reason behind removal of pendant edge is that pendant edge will be a part of every spanning tree.

Thus removing pendant edge will reduce the complexity of the problem. Figure describes an example of

one such instance.

In this figure, if we choose v1 as the reference vertex and then, e4 is the pendant edge. The remaining

graph after its removal is G1 in figure b. This pendant edge will be added later in every spanning tree.

Division of Graph into Subparts:

After choosing reference vertex and removing the pendant edges, we can start working on dividing a

simpler graph. There are two sub steps in this step. The first step is to compute the main partition and

then generate subsidiary partition for every main partition.

Computation of Main Partition:

Main Partition consists of all possible sets of edges that comes out of reference vertex. If we have n

edges coming out of reference vertex, then we will have 2^n – 1 main partitions.

Computation of Subsidiary Partition:

After we compute the main partitions, then we use each partition to compute their unvisited vertices.

For each main partition, we first calculate the vertices that the edges in the set have visited, and after

that we calculate the vertices which are left unvisited.

After the calculation of unvisited vertices, we compute all possible combination of unvisited edges that

are present in the graph. Let us say we have 4 unvisited vertices for a particular main partition A, B, C

and D. Then the distinct combinations of edges are (AB, CD), (AC, BD) and (AD, BC). We have these three

distinct combinations which can be formed from 4 unvisited vertices. The next step is to figure out

which edges are present in the graph and which are not. We have to remove the combinations which

are not in the graph. Remaining combinations are the subsidiary partitions for that main partition. In

case of 5(odd) unvisited vertices, we will have at most 2 unvisited edges and 1 unvisited vertex.

Computation of Connections between Subparts:

This step deals with finding the connections between main and subsidiary partitions and also,

between different components of subsidiary partitions. These two findings are divided into two parts.

First part is to find the connection between main partition and subsidiary partition (MS connector) and

second part is to find the connection between multiple subsidiary partition components (SS connector).

Computation of MS Connectors:

In this sub-step, we first calculate the visited and unvisited vertices based on the main partition. Then

we compute the edges that are present in the graph such that it joins the visited vertices with unvisited

vertices. We will make sure that none of the edges contain reference vertex in them, as they can’t be

used in any step barring first. These set of edges are termed MS connectors.

Computation of SS Connectors:

In this sub-step, we will compute all possible combinations of edges that join corresponding

combination of subsidiary partitions. Let us take previous example of (AB, CD). In this, we have AC, AD,

BC, BD as the four possible connectors between partition components. We will compute all the possible

connectors and remove the possibilities which are not present in the graph. These possibilities will be

termed as SS connectors.

Combination of Sub-Parts:

This is the final major step in this algorithm in which we combine the subcomponents to form

spanning trees. This is divided into two sub-parts: first part combines the partitions together one by one.

In the second part, we deal with multiple parts of one single section to form special trees.

Phase 1 of Spanning Tree Combination:

As we know in the previous sections, we divided the graph into main and subsidiary partitions and then

computed MS and SS connectors. In this phase, we will join main partition with one main connector (MS

connector), one subsidiary partition and one subsidiary connector (SS connector). This will be done for

each main partition and will result in one spanning tree, for each computation.

Phase 2 of Spanning Tree Combination:

In phase 1, we combined all parts from previous sections, and created spanning trees. But those trees

include one main connector (MS connectors) only. There will be cases in which more than one main

connectors will be joined together to form spanning trees. This phase deals with such cases. Here, we

will remove those partitions which have either zero or one MS connector. Also, we will remove such

cases which only contain unvisited vertices considering these cases will lead to duplication. For the rest

of the cases, we will first create combinations of two or more main connectors and add primary

partition in them. The resultant combinations will work as main partition for the same algorithm. And,

using these as main partitions, we will run the same algorithm and will generate the rest of spanning

trees.

Combine Pendant Edge:

This step is to join pendant edge that we removed in step 1 in all the trees generated in the last step,

both phases. This step will give all the spanning trees of the graph.

Removal of Crossing Spanning Trees:

This is a side step joined together with this algorithm to meet the desired objective of generating

crossing free spanning trees. In this step, we will take all previously generated spanning trees from both

the phases after adding pendant edges, and will remove those trees which are crossing each other. One

of the best ways to solve this problem is to find the orientation of two line segments with each other [2]

and if their orientations are same then they don’t cross/intersect each other, otherwise they do and we

remove the spanning tree from the set. In other words, we will compute the vector product of one line

segment with both the points of other line segment and then we will remove them from the set based

on the results [2].

Algorithm:

Step 1: Take a graph G.

Step 2: Select a reference vertex (Vref).

Step 3: Remove pendant edges associated with Vref.

Step 4: Find all the edges that comes out of Vref and compute all the combinations of the edges (Main

Partitions).

Step 5: For each Main Partition:

Calculate Subsidiary Partitions containing unvisited edges, and unvisited vertices.

Calculate Main Connectors joining Main Partitions and Subsidiary Partitions.

Step 6: For each Subsidiary Partition:

Calculate Subsidiary connectors joining subsequent connector components.

Step 7: Form trees joining Main Partition, Main Connector, Subsidiary Partition and Subsidiary

Connector.

Step 8: Remove the options which contains either zero or one main connectors and also, the options

which contains unvisited vertices only and generate combinations of main connectors for each Main

Partition.

Step 9: Join each combination with Main Partition, and considering these as Main Partition, recurse

through the whole algorithm again.

Step 10: Join Pendant edges in trees generated in step 7 and step 9.

Step 11: Remove the trees which are crossing over each other.

Example:

Step 1: Vref = A

No pendant edges from A.

Step 2: Edges from A: AB, AC, AD

Combinations: {AB}, {AC}, {AD}, {AB, AC}, {AB, AD}, {AC, AD}, {AB, AC, AD}

Step 3:

Main

Partition

AB AC AD AB, AC AB, AD AC, AD AB, AC,AD

Subsidiary

Partition

CD BD BC D C B Null

Step 4:

Main

Partition

AB AC AD AB, AC AB, AD AC, AD AB, AC,AD

Subsidiary

Partition

CD BD BC D C B Null

Main

Connectors

BC& BD BC& CD CD& BD CD& BD BC& CD BC& BD Null

Step 5:

Since there is only one or zero subsidiary partition for every main partition, there will be no

subsidiary connectors.

Step 6:

Phase 1(Join Main Partition, Main Connector, Subsidiary Connector and Subsidiary Connector):

1: AB, BC, CD 2: AB, BD, CD

3: AC, BC, BD 4: AC, CD, BD

5: AD, CD, BC 6: AD, BD, BC

7: AB, AC, CD 8: AB, AC, BD

9: AB, AD, BC 10: AB, AD, CD

11: AC, AD, BC 12: AC, AD, BD

13: AB, AC, AD

Step 7: The main partition {AB, AC, AD} is removed as it doesn’t contain any subsidiary

partition. Also, partitions {AB, AC}, {AB, AD}, {AC, AD} are also removed as they only

contain unvisited vertices. The remaining main partition left are {AB}, {AC}, {AD}.

Thus the combinations are: {AB, BC, BD}, {AC, BC, CD} and {AD, CD, BD}.

Step 8: These are the main partitions and surprisingly, they all have no unvisited vertices. Thus,

they will be introduced as spanning trees. So, all spanning trees after both phases are:

1: AB, BC, CD 2: AB, BD, CD

3: AC, BC, BD 4: AC, CD, BD

5: AD, CD, BC 6: AD, BD, BC

7: AB, AC, CD 8: AB, AC, BD

9: AB, AD, BC 10: AB, AD, CD

11: AC, AD, BC 12: AC, AD, BD

13: AB, AC, AD 14: AB, BC, BD

15: AC, BC, CD 16: AD, CD, BD

Step 9: There are no pendant edges removed. Thus, there will be no edges added.

Step 10: After processing through the crossing free algorithm, as described, we got these

spanning trees left which can be termed as crossing free spanning trees for this graph:

1: AB, BC, CD 2: AB, BD, CD

3: AD, CD, BC 4: AD, BD, BC

5: AB, AC, CD 6: AB, AD, CD

7: AB, AD, BC 8: AB, BC, BD

9: AC, AD, BC 10: AD, CD, BD

11: AB, AC, AD 12: AC, BC, CD

Novel Algorithms

This project works with geometric graphs to generate all crossing free spanning trees. To meet this

objective, we constructed our own algorithms such as Crossing free Spanning Tree and randomized

Markov Chain algorithm.

3.1 Crossing free Spanning Tree

There are a lot of ways with which we can generate crossing free spanning trees. One simple approach

would be to take a vertex (A), and draw line segments from that vertex (A) to every other vertex in the

graph. This will give us a Crossing Free Spanning tree. We can easily prove its crossing free property by

saying that since every line segment starts from one vertex (A), you can’t have two line segments

intersecting each other. Also, it will have spanning tree property as there will be n-1 line segments and

also, every vertex will be connected with every other vertex (in figure).

Figure: Crossing Free Spanning Tree

But the algorithm better suited for this project is discussed below:

Step 1: Take a set of points and generate a convex hull from them. This will draw an outside perimeter

for the points. We call the points lying on the perimeter as outer points and the remaining points which

are not part of that convex hull as inner points.

Step 2: Remove one edge (any edge) from that convex hull.

Step 3: Go over each inner point and find the closest distance from that point to the outer points and

join them.

Step 1 Step 2

Step 3

3.1.1 Crossing- Free Verification

* The edges of the outer circle will never be crossed as the only way any of the outer edge will be

crossed is to have one point outside that convex hull and if that happens, then that outer point will

already be a part of convex hull.

* For the inner edges, each inner point will have one closest outer vertex. Points which will not follow

this will be the points that lie on the perpendicular bisector of the outer edge. These inner points will

have two closest points. In any of these situations, the edge connecting the inner point to the closest

outer point will not cross any other edge joining inner point will the outer point.

However, in case of collinear inner points, two lines will overlap but they can be seen as two lines with a

point in between.

3.1.2 Spanning Tree Verification

*There are always n-1 edges drawn from this algorithm. Let us consider that the no of outer vertices are u and inner vertices are v. Then the outer edges from Step 1 will be u. Then we remove one edge at random which makes the total edges u-1. Step 3 will generate v edges as there are v inner vertices connected with outer vertices. Thus, total edges are u+v-1, when total vertices are u+v.

*All the vertices are connected with each other as all the outer vertices are connected using the convex hull and each inner point have one edge with the outer vertex.

3.2 Markov Chain Principle

After designing the algorithm to generate a crossing free spanning tree from a pool of points, we have to use that spanning tree in generating all crossing free spanning trees randomly.

Algorithm to generate all crossing free spanning trees at random:

Step 1: Choose a random root for the current crossing free spanning tree and convert the undirected graph to directed pointing towards the root.

Step 2: Choose a random edge e and the random direction for the edge (u,v).

Step 3: if the edge doesn’t belong to the previous spanning tree and u is not the root and new edge will not cross over the old edges, then remove parent edge of u from the spanning tree and add that edge in the previous spanning tree.

A directed graph with B as root. Randomly chosen edge MH.

Since the edge MH is crossing over KL, we have to go for other iteration.

A new random edge KH chosen. New Crossing free Spanning tree

3.2.1 Verification of Symmetric nature

Markov Chain Principle is symmetric in nature as we know that the new edge is always drawn at random. Thus, the probability of drawing an edge is 1/ total number of possible edges.

Let us say that we have a crossing free spanning tree T and we draw an edge at random, which satisfies all three conditions: u is not the root, new edge is not crossing previous all edges and new edge is not part of previous spanning tree. Thus, based on our algorithm, we will remove a parent edge of u and add new edge to create a new crossing free spanning tree T’.

Taking T’ as the current crossing free spanning tree (T’) and we draw another edge at random. Let us say that the new edge drawn at random is the parent edge we removed previously with the probability of 1/ total no of possible edges. Since u is definitely not a root, new edge is not part of T’ and new edge is not crossing T’. We can remove the parent edge of u and add new edge to move from T’ to T again.

Thus P(T to T’) = P(T’ to T), hence Markov Chain Principle is symmetric.

3.2.2 Verification of reach-ability of all Spanning Trees

In order to prove this, we will start with one form of Crossing Free Spanning Tree and will reach the other. If we are able to do so, it means that we can reach any form.

Let us take an example of one simple Crossing Free Spanning Tree.

We will start with vertex A and one edge (let us say that edge is the topmost edge) and will find an edge which will cover two edges in direct connection with A and are not crossing any other edges as explained in figure below.

This way we have an edge completing a closed shape. Now, we can remove the middle edge (second top most) as this structure is not spanning tree (due to one more edge). This will give us a structure shown below.

The next edge will be taken between H and G and the edge AG will be removed as a result of that. Thus we will keep on doing this, until we will reach a graph where all the vertices are connected with other. Thus, we have transformed one form into another. Hence, every crossing free spanning tree can be reached.

Algorithm Analysis

This section describes the flow of the whole algorithm and its analysis based on their complexity.

4.1 Flow Chart of the Algorithm

4.2 Algorithm Complexity Analysis

Enumerating through all Crossing Free Spanning Trees:

Storage of graph: O(m+n), where m is the number of edges and n is the number of vertices.

Worst time complexity of the algorithm: O(n. 2^n)

Novel Crossing Free Spanning Tree:

Finding Convex hull: O(nlogn), n is the no of points.

Finding closest point for n points: O(n^2).

Total worst time complexity: O(n^2)

Setting up the environment

This section comprises of all the steps required for the novice user to execute the program. The main

component required for this project to execute is to input a file with specified input requirements and

then the location where the intermediate results are stored.

5.1 Input Type

For this approach, a user will input the vertices of a graph using a specific formatted file where every line

will hold three values such that the first value describes the name of the vertex, second value describes

the x-coordinate of the vertex and the third value is the y-coordinate. These three values are separated

by a space.

Example:

A <space>10<space> 11

B <space> 298 <space> 175

C<space> 976 <space> 1

This program is tested on integer point values but it will work on double values as well.

5.2 Intermediate Results

This project will generate images of all the crossing free spanning trees as intermediate results which

can be used later. In our project, apart from using JFrame to draw each crossing free spanning tree, we

are also saving them in a specified repository so that they can be used as evidence of the number of

crossing free spanning trees calculated.

Experimentation and Results

After running the program for 5 vertices with locations described below, the intermediate results

generated (all crossing free spanning trees) are:

Points:

A 2 3 B 36 28 C 26 712 E 125 25 F 700 700

The total number of crossing free spanning trees generated is: 77

For these 5 points, some of the crossing free spanning trees generated are:

Image 1

Image 2

Image 3

Image 4

Image 5

After generating all crossing free spanning trees, a crossing free spanning tree is generated and using

this spanning tree as input for the Markov Chain Rule algorithm, the results obtained are:

Total number of Crossing Free Spanning Trees generated (Enumeration of all Crossing Free

Spanning Trees): 77

Total number of samples tried (Using Coupon Collector problem): 77 ln 77 + 0.577215 * 77

=~378

Markov Chain steps/moves per sample: ~9200

Conclusions

We are able to generate all crossing free spanning trees for experimented set of vertices for the graph.

We experimented with generating single crossing free spanning tree and using it to randomly produce

crossing free spanning trees. The sample results are inconclusive to reach the hypothesis (algorithm

needs polynomial number of moves to reach uniform distribution). More experiments are required to

state about the hypothesis. Framework/Set-up is created for further exp.

Future Work

1: More experiments are required to match the hypothesis.

2: The experiments are tried for integer valued location for vertices. It can be tested for double values as

well.

3: The run time complexity can be reduced as the filtering of crossing spanning trees are done on the

last step of our enumeration algorithm. The filtering can be done during the process such that those

branches which are crossing can be filtering once they are generated, in the earlier steps.

4: The experiments can be tried for larger graphs.

References

[1] Chakraborty, Maumita, Ranjan Mehera, and Rajat Kumar Pal. "A Divide-and-Conquer Algorithm for All

Spanning Tree Generation." Advanced Computing and Systems for Security. Springer Singapore, 2017.

19-36.

[2] http://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/

[3] https://en.wikipedia.org/wiki/Markov_chain

[4] https://web.stanford.edu/class/stat217/New12.pdf

[5] http://setosa.io/ev/markov-chains/

[6] https://en.wikipedia.org/wiki/Coupon_collector%27s_problem

[7] Char, J. "Generation of trees, two-trees, and storage of master forests." IEEE Transactions on Circuit

Theory 15.3 (1968): 228-238.

[8] Shioura, Akiyoshi, and Akihisa Tamura. "Efficiently scanning all spanning trees of an undirected

graph." Journal of the Operations Research Society of Japan 38.3 (1995): 331-344.