>> Host: Okay, good morning. Welcome to Graph Drawing 2012. It’s a
great honor for me to open this conference, especially this year that
the Graph Drawing Symposium celebrates its 25th anniversary. First of
all [inaudible] and I wish to thank all people who work had for this
event. So many thanks to Lev Nachmansen and the other members of the
organizing committee and thanks’ to Microsoft to housing this
conference.
We are also grateful to all the sponsors that gave to the budget from
the mentor contribution. Let me thank also the [inaudible] members who
did a wonderful job with this election of papers and posters for this
conference.
And special thanks go to the auditors who decided to submit to the GD,
because their submissions that are presented needed the heart of the
conference.
And I also want to thank the [inaudible], so professor [inaudible] and
professor [inaudible] for accepting our invitation. We are honored by
their presence.
As you know, this year the Graph Drawing Symposium experimented for the
first time in its history the double [inaudible] for paper submissions.
And we are very happy to report to you that these settings work very
well. And we have received many, many submissions during the business
meeting. We will try to give you some statistics about submission
numbers, acceptance rates and comparisons with previous graph drawing
additions.
In the program, as you can
practical talks. And this
dynamic and lively program
label that will inform you
see, each session mixes both theoretical and
has been done in order to have a more
indeed. Near to each talk you can find the
about the corresponding track.
But for these 20 years of GD we also prepared some special initiatives.
First concerning the graft drawing contest, the usual graft drawing
contest, we have this year games besides the classical competition.
And we need to evaluate these games. So we invite you, we warmly
invite you, to play with these games and to score them based on their
fun factor. You will have the chance to play during coffee breaks and
also during the session devoted to GD which will take place this
afternoon, from 5:30 to 7:00 pm. Let me thank the committee of the GD
contest for this very nice initiative. And the winners of this
competition will be announced during the social dinner of tomorrow
night.
As I say on [inaudible] there are two best papers, words, and one for
each track. We already signed these press papers and they have been
announced at the website of the conference, which is also indicated in
the program, but again the winners will receive some money and
certificates during the social dinner.
And as a third initiative following the suggestion of [inaudible] last
year, we established a new award category which we call the best
fundamental paper award. We assign this award to a single paper,
either a journal or conference paper which represents a fundamental
contribution in the field of graph drawing. And hopefully this kind of
award will enter in the tradition of [inaudible] we continue next year.
So, in order to assign this award we needed a small committee whose
members are listed in the graph drawing website. And I warmly thank
all these people for all their support and their work on this specific
task.
Again, the winning paper will be announced tomorrow during the social
dinner and it will receive a special mentioning on the website of the
conference for its merits in the field.
I think it’s so, let me recall you that coffee breaks and lunch will
take place beyond that door. There is a room there. And I wish to
thank you again for attending this event. Thanks’ for the attention
and [inaudible], me and [inaudible], who is not in the picture, he is
actually there, [inaudible]. Thank you very much [inaudible].
[clapping].
So probably Alex wants to open the next session.
>> Alexander Wolff: Okay, it’s my pleasure to start the first session.
My name is Alexander Wolff, but I am just called Sasha and I welcome
you here too. And the first talk is by Micha Sharir and, what’s your
first name?
>> Adam Sheffer: Adam Sheffer.
>> Alexander Wolff: Adam Sheffer on counting plane graphs, cross-graph
charging schemes. Please, Adam.
>> Adam Sheffer: Hi, so as said I am Adam and I am going to be talking
about this work called counting plane graphs: cross-graph charging
schemes. It’s a joint work with my PhD advisor Micha Sharir.
Now we have all sorts of results in this work, but the thing that I am
excited the most about is the technique itself which we call crossgraph charging schemes. And I will want to try to convince you that
it’s an interesting technique, but before I can do that I need to
present some definitions and some problems so we will have motivation
for the technique.
Were the
you have
and they
that are
examples
language straight edge crossing free graphs, more specifically
a set of points in the plane, we are not allowed to move them,
are fixed. And we are interested in straight line segments
known crossing. We call these plane graphs. You have some
here. Now notice the distinction from plane graphs.
These two graphs are actually planar in the sense that if I can move
the points I can fix the problems, but in our context they are not
plane graphs. Given a set of points, for example this set, we can
embed many different such plane grafts on the set, which leads to a
bigger problem. What is the maximum number of plane graphs that can be
embedded over a set of land points? We call it pg of N, so we want to
say that if you give me a set of end points, any set of end points, I
can tell you that there are at most pg of N plane graphs that can be
embedded over this set. We want to find out what this pg of N is.
So just to make it clear let’s do an example. Let’s find pg of 4, the
maximum number of plane graphs that can be embedded over any set of 4
points. So I need to go over all sets of 4 points in the plane. But
actually there are only 2 cases. A quadrilateral convex and a
triangular one, because if we slightly perturb the points it will not
change the number of plane graph that can be embedded over the set. So
you can very easily in one minute calculate that this is what we get in
both cases. And pg of 4 is 2 to the 6th, every set of 4 points to the
plane that you give me. [inaudible] 2 to the 6th plane graphs that can
be embedded over it.
Now a specific type of plane graph is a triangulation. I am sure you
all know it. One definition is that it’s a maximal plane graph in the
sense that I cannot add any more straight edges without crossing
existing ones. And I can ask exactly the same question for
triangulations. I can ask what --. I tr of N is the maximum number of
triangulation that can be embedded over any set of end points in the
plane.
So in a previous work we showed it as any set of end points in a plane
has strictly less than 30 to the N triangulations that can be embedded
over it. And the best known lower bond is 8.65 to the N. There is a
point set with this number of triangulations. So you see there is
still some gap here. And there are many other variants. I can ask how
many plane spanning trees can be embedded over a point set, or perfect
matching, or spanning cycles and if you look at the literature there
are works on many, many variants.
There really are a lot of variants that people have studied. Just in
case you are curious here are some of the best know bounds for some of
these variants. So you can see that for some problems we have, there
is still a large gap. For some problems there is a slightly smaller
gap, but we are still far from knowing these values. There is still a
lot of work to be done here, even though there are works on these
problems for over 30 years now.
Okay. So we have some problems and now we can start talking about the
technique. It’s called cross-graph charging schemes. So first let’s
just recall what the charging scheme is. I am sure most of you know
what it is, but still just let’s do a quick reminder.
It’s basically an analyzing method, a bounding method. And we are
putting charge on vertices or edges or whatever and move it. Probably
the most famous use of it is the proof of the four color theorem which
heavily relies on a charging scheme.
Now I know you probably know what it is, but I am going to spend on
minute just to remind you how it works because I am going to need it
later. So let’s do a very trivial example. Let’s prove this
completely trivial property. A graph with n vertices and maximum
degree of D has an independent set of this size. For example here I
have maximum degree 3 [inaudible] so the claim says that there is an
independent set of side 2, not very interesting. You can also find an
independent set of side 3.
So, charging scheme is basically double counting method. We put the
charge in bounded, we move the charge in bounded again and we have a
double counting. So let’s just do this very fast. Here I can put a
charger [inaudible] on every vertex. So let’s say that the charge is C
and the total charge is N, right. And vertex is 1 charge on 8, so this
is one bound over the charge. And I want to move the charge and bound
it again. So each time I am going to choose a vertex, say I choose
this one, put it in my independent set and give it the entire charge of
its neighbors. So, for example it will get all of charge of these
three vertices here and then the graph will look like this. Now I
choose another vertex, I do the same and I am done. No more vertices
we charge.
So let’s use this to bound it again. Now the entire charge is on
vertex of the independent set. Only on vertex of independent set S.
And each set vertex has a charge of at most D plus 1, because well it
started with one and got a charge of it mostly from its neighbors. So
I know that the charge is at most the number of vertex of independent S
times D plus 1. So it got two bounds on the charge which equals then
this. Combining them immediately gave me the claim I want. Sorry for
boring you with this. I just wanted to remind everyone how it works.
Okay. So you probably know some other charging schemes. What we do
differently, what we are talking about that’s different is that we are
going to move a charge across different graphs. That is, a vertex in
one graph might give charge to a vertex in a specifically, in a
completely different graph. As far as I know the first instance of
such a use, an idea, was by Sharir and Welzl in ‘06 where they proved
that the maximum number of triangulations for any set of end points is
43 to the N.
Then it wasn’t really a technique, it was an analysis for a specific
problem, very specific to their problem. But very soon they found out
that we can use it to do other things. Here are some examples. We
show the converse, that every set of end points in the plane has at
least some number of triangulations, or we showed some properties of
[inaudible] triangulation. I am going to explain what this means soon.
We improved the 43 to the N down to 30 to the N and there was even an
algorithm.
Razen and Welzl show an algorithm that gets a point set S and counts pg
of S, the number of plane graphs that can be embedded over it in a time
that is exponentially faster than pg of S. That is exponentially
faster than the time it will take it to numerate all these graphs.
Okay. But all of these works are actually about triangulation, even
this one, although it doesn’t seem like it, it’s about triangulation.
And the charging scheme was between vertices of different
triangulations.
Specifically it relied heavily on flipping of edges in triangulation;
probably you know what it means. If not I saw that we are going to
listen to an invite talk about this tomorrow. What we did in this work
is that we showed the technique is actually much more general. It can
be applied to many types of different graphs, stuff that’s not related
to triangulations at all. And even we found it a bit surprising; it
can even be applied to some graphs that do have crossings, a non-plane.
So, I am going to show you how this works, but first let me just show
you some stuff we can do with this technique to convince you that it’s
interesting, that it’s
can use it to get some
upper bound of pg of N
of other problems, but
useful and then sort of how it works. First we
improved bounds. For example we improved the
and we get slightly better bounds for all sorts
I don’t have time to talk about them.
Okay. We can study random plane graphs. What’s a random plane graph?
So we say that if we have a point set, a random plane graph of this set
is taken, is one uniformly chosen from the set of all plane graphs of
this plane set. For example if I have this set of 3 points there are 8
possible plane graphs. It shows that each one is chosen in a
probability of 1 over 8.
These graphs are hard to study. You can’t use the standard technique,
the probabilistic method, or the [inaudible], etc, because you can’t
just take very edge with some fixed probability. You might get
crossings. We are not allowed to have such crossings. So the common
methods fail. And we can use cross-graph charging schemes to get
properties of such graphs.
Here is an example. We get all sorts of properties and this is just
one example. Let’s say that V top I is the expected number of vertices
of degree I in a random plane graph. For example if we have these
three points again, it will go over the possibilities. You will see
that an expectation, the number of vertices of degree 0. Isolated the
vertices is going to be 3 quarters. So we show that we can get all
sorts of bounds on the expected degrees.
For example we can show that v top 2 plus v top 3 is always at least N
over 24 [inaudible]. Any point set that you take you expect that there
will be a lot of vertices of the degree 2 or 3; one of each 24 vertices
in a randomly chosen graph. At least one of each 24 vertices will have
a degree of 2 or 3. That’s just one example. We can show all sorts of
properties.
And finally I said that we can show stuff about graphs that do contain
crossings, graphs which are not planar. So we studied k-quasi-plane
graphs. A k-quasi-plane graph can contain crossings, but it’s not
allowed to have a set of k pairwise crossing edges.
For example 2-quasi-plane graph is not allowed to have a pair of
crossing edges. So it’s just a plane graph. 3-quasi-plane, this is
for example a 3-quasi-plane. It has crossing, it’s not even planar,
but it doesn’t have a set of 3 pairwise crossing edges. There are all
sorts of forks on such graphs. I think that mostly trying to bound the
maximum number of edges that they can have, but I am not familiar with
any previous counting results.
And we show that you can upper bound the number of graphs, our
technique in upper bounding the number of such graphs for 3-quasi-plane
graphs and 4-quasi-plane graphs. Now you can see that these are very
large bounds. This is the number of 4-quasi-plane graphs is
astronomical. However, we think it’s nice because it’s the first time
that we know that the number of such graphs is exponential. Before
that it might, we didn’t know if there might be a point set with a
super exponential number of 3 or 4-quasi-plane graphs. Now we know
that it cannot happen. We suspect that this is the case for every
fixed K, but I am not going to get into this.
Okay. So, I am going to show you how this works now, but I just want
to say first we started with a very specific --. This technique
started with a very specific analysis for a specific problem. Then it
got generalized to a set of problems all related to triangulations.
Now we show that it’s even more general. It can be applied to all
sorts of plane and plane related graph types and you can do more stuff
with it. And I am excited about this because I wonder what else we can
do, maybe we can generalize it even further, solve more problems with
it. So though this direction is just to apply to more graphs, I bet we
can find some more types of plane related graphs that we can use it
for.
But I think it’s more interesting to ask what we can do beyond. For
example this technique is useful because it allows us to study random
plane graphs which are hard to study. Maybe there are different
families of graphs that are hard to study in random model and then we
can somehow use this technique to study them, or maybe we can use it
for something completely different. Why are we stuck on a specific
point set? Maybe we can use it to count something like sub-set, subgraphs of a different family of a given graph, or I don’t know what.
So if you have an idea on what you might think of something this might
be applied to I would be very happy to talk to you. I won’t mind if
you come to me at some point in the conference. Now with the time I
have left let me just show you how this works, briefly.
I am going to show you how to bound pg of N. I am not going to get the
new and improved bounds, some worse bounds, just to see how this works.
First I am going to use this lemma. Okay. First the lemma says that
if I have some positive constant delta, such that this holds, we will
see what this means in a minute. V top 0 is always at least delta N.
Then I get an upper bound of pg of N.
Now let’s do it slower and try to understand what this means. Say for
example the delta is 1/100. So this says that if I can show that for
any set of end points that I take, if I take a random graph I expect to
see at least N over 100 isolated vertices, vertices of degree 0, then I
get a bound of 100/N for the number of plane graphs. That is, if I get
a lower bound on the expected number of isolated vertices in a plane
graph I get an upper bound of pg of N.
I am not going to prove it because I don’t have time, but it’s really
not complicated to show this. I am going to show you how to get this
lower bound. And this is where the cross-graph charging schemes comes.
Now we are going to move charge between vertices of different graphs so
we need a new notation. We call it a ving. A ving is an instance of a
vertex in a graph.
For example here is the point set. Here is some vertex v, here is a
graph over this point set g, and a ving is an instance of v in g. It’s
specifically, you can think of it as a pair of a vertex in a graph.
And if the vertex has the degree of I in the graph we call it an iving. For example this is a 4-ving because v is as a degree of 4.
Okay. So let’s use the charging scheme. We want to put charge and
bound the charge and then move the charge and bound it again. Double
counting just as we did before. So we are going to put a charge of 7
minus I for everything in every graph. For example here is a 5-ving
that got a charge of 2, 1-ving got the charge of 6. A graph with a
ving with a very large degree will have a very negative charge. This
is very similar to what happens in the proof of the four colors here in
order to give every vertex a charge of 6 minus I.
And we use also a very similar analysis that shows you that on average,
oh sorry, not on average, the total charge is larger than the total
number of vings. Okay. It’s not hard to show, it’s very much like
what’s happening on the proof of the four color theorem. That’s one
bound of the charge on the charge. The charge is larger than the
number of vings.
Now we want to move the charge and bound it in a different way. So we
are going to move the entire charge to 0 vings. Just like before we
moved the charge to vertices of the independent set, now we are going
to move it to 0 vings.
Let’s take this 3-ving which has a charge of 4, it’s in the graph g.
Now we want to throw away all the edges that are adjacent to it, all
these three edges. We get a different graph g prime. In this graph
our vertex is a 0-ving, because there are no edges into it. So this 3ving is going to give all of its charge to its 0-ving, and that’s going
to happen for all of the vings. Every ving is going to give its charge
to the 0-ving by throwing all of the edges adjacent to it.
If you do this you can show that every 0-ving is charged at most 2 to
the 12. This may seem counter intuitive because what if some 0-ving is
charged by 1 million 1-vings. Each 1-ving has a charge of 6, so this
is a charge of 6 million, it’s much larger, but the intuition is that
if there are a lot of vings with a positive charge that charges 0-vings
there will be a lot of vings with a negative charge to charge it. For
example if you have 1 million 1-vings that charge it you are going to
expect to find more than 1 million 100-vings that charge it. And each
one of them has a charge of minus 93.
So if there are a lot of vings that charge it, it is going to have a
very negative charge. This bound 2 to the 12 is tight and is obtained
when there are, I think there 12 1-vings to charge it. Okay. So let
me just wrap it up.
So we counted the charge in two ways. First we said that the total
charge is larger to the total number of vings. Then we moved the
entire charge and said that the total charge is at most the number of
0-vings times 2 to the 12, because all the charge is now in 0-vings.
Combining these two gives us exactly what we want; the lower bound and
the expected number of 0-vings in a graph. So this will give us a
rather bad bound. It will give us a bound of 2 to the 12th N. But
using some more tricks you get the new and improved bound that I
mentioned before. And that’s it, thank you very much.
[clapping].
>>: Any questions for Adam?
>>: A very clear presentation.
>> Adam Sheffer: Thank you.
[clapping].
>>: Nice talk.
>> The next speaker is Joe Fowler who will talk about planar
preprocessing for spring embedders [inaudible].
>> Joe Fowler: So, my name is Joe Fowler. I am from the University of
Arizona. This work is in conjunction with Stephen Kobourov. And I
will be talking about planar preprocessing for spring embedders.
So spring embedders are nice drawing algorithms that can draw any
graph. Not necessarily just planar graphs of course. And the work by,
well there is different classes, there like Fruchterman and Reingold
which are four stroke algorithms. It’s also like multi-dimensional
scaling ones like mine [inaudible]. But the idea with the FR1 is that
those that are adjacent are pulled toward each other and those that are
not adjacent are pushed from each other. They iterate so many times
that they tend to give fairly decent graphic studies. Like in terms of
node separation, edge length ratios, trying to avoid small edges verses
big edges, angular resolution, trying to avoid having the really sharp
angles, but they don’t consider edge crossing, straight line
[inaudible].
>>: [inaudible]
>> Joe Fowler: Do I need to repeat myself or did they get that?
continuing.
Okay,
So with plannar drawing algorithms of course you get rid of all the
crossings and they run much faster. They run in linear time compared
to spring embedders that can take quite a bit longer. Like quadratic
time per-iteration or more. But one of the drawbacks of straight line
planar algorithms like for say Pach and Pollack, Schnyder and Kant, is
that they tend to have areas where they will really compact all the
nodes into a small place, which will lead to small edges compared to
long edges. And they don’t do the best job with angular resolution
either.
So, the question that we are asking here is that, well spring embedders
are influenced by the initial layout you start off with. So typically
they start off with a random layout and they iterate from there. Now
you would think that if you give it a planar layout where it starts off
with planar it would do better crossing lines than with the random one
that tends to have a lot of crossings?
But that isn’t necessarily obvious because these algorithms by the very
nature of how they work they tend to do these really big initial moves,
in the beginning, and they totally destroy the planarity. So it would
be nice, because crossings to do tend to interfere with the readability
of the graph, if we could do something to help reduce the crossings
generated by these spring embedders because they do well otherwise.
Now in terms of previous work there has been some like Harel and Sardas
used like simulated annealing and there are very classic algorithm
using, but they improved upon a planar layout. Bertault actually
devised one that took edges and vertices into account, but then had to
consider all the edge and vertex pairs. In comparing like multidimensional scaling to force-directed layouts Brandes and Pich showed
that they are indeed better at giving your ideal edge lengths.
So one application for when you might want to layout a planar graph
using a force directed method is by vanHam and Wattenberg. Now what
they did is they had a real world graph, it was a nice one where it was
a lot of clusters, but had a small diameter. So it had some edges that
were common to many shortest paths. And so when you use your typical
force directed algorithm to lay this thing out it just looked like a
hairball. So their idea was to extract a planar subgraph with the
lowest betweenness which is betweenness based off the number of
shortest paths and edges in. And they got about 80% of the edges were
in this planar subgraph and they used force-directed to lay it out.
And then added in the high bid edges later and that was a much more
readable graph.
So this is an explicit example where you might want to use forcedirected on planar subgraphs. One thing that is sort of related to
what we did is Didimo, Liotta and Romeo used poly-line layouts where
you have an orthogonal way out or one from planarization and they
iterate on that. And they had their own force-directed layout that
didn’t introduce [inaudible], but it did have curves or bends in the
edges, which is different than what we are talking about. I am talking
about straight line drawings.
Now in our experiments we had six different libraries that we examined.
Two of them were trees, the proof from one is uniformly sampled labeled
Trees where then we discard the label. That’s not the same thing as
un-labeled. And random trees which is the standard one where you just
randomly attach edges. So those are trees, two different types.
Fusy graphs are uniformly sampled unlabeled planar graphs, not plane,
but planar graphs and expansion graphs are random triconnected graphs
formed by starting off with a k4 and randomly un-contracting a vertex
into two vertices and then distributing the adjacencies to keep it try
connected.
We also looked at two real world graph sets, ROME graphs and AT&T
graphs and picked the ones that were planar from that. So out of the
ROME library there was over 11,000 and 3200 were still planar.
Now for the generated sets, the first four ones, we went from N equals
10 to, n is the number over vertices, to 100 and we had 10 each. And
you will see that with trees of course the 50 is the median you have,
you know; your average degree is about 2. And when you go for like the
truly random ones Fusy goes from 2.2 to 4.79 or range, but still its
generally twice as many edges as a tree. And expansion graphs are a
little bit more. But these real world graphs, which is interesting,
their median values in terms of the average degree is fairly close to
trees.
So there are not that many more edges than trees. So it shows that
people typically tend to layout these sparse graphs and often times
they can be planar. So in terms of our experiment what we did was that
first we have our initial random layout that most of them start off
with and then we looked at three different planar drawing algorithms.
We used OGDF for everything which is Open Graph Drawing Framework,
which used to be AGD.
And FPP is the classic one for say Pach and Pollack on the 2n minus 4
by n minus 2 grid using canonical ordering. Schnyder uses a different
method with the SCHNYDER realizer. It’s a more compact on n minus 2 by
n minus 2 graph actually half of that. So it’s the most compact. Kant
is more like FPP, but has a better choice for outer face and what not
so it tends to not compact things quite as much.
Now for the Spring Embedders we will mainly look at the Fruchterman and
Reingold verses Kamada and Kawai. We also, this was another simple one
we just threw in, but it’s meant mostly as a preprocessing step itself.
Now there are two different versions of this FR algorithm in OGDF.
There is the standard one which is actually a grid varying
approximation. Then they have one that also does exact computation
that takes longer to run of course. And we are mainly trying to
compare the FR variance to KK the Kamada and Kawai multi-dimensional
scaling.
Now we looked at four different aesthetics, the number of crossing just
a simple number. These other ones are a little bit more involved. So
minimum angle metric, this is taken from Helen [inaudible] article
about different metrics for graphs. And here you are taking the ideal
angel. So if you have four edges incident to angle, the ideal angle
that you can put it in where everything is nicely distributed is 90
degrees. And if you have 100, or 180, it would just be 1 degree. So
you are not going to penalize a sharp degree just because it’s a high
degree vertex.
And you are taking the average deviation of this, subtracting one from
--. Subtracting it from 1, so 0 is bad, one is good. So 1 is when you
have particular angular resolution and 0 is when everything is just on
top of each other. And these other ones work in a similar way with
edge lengths. This is fairly straightforward, doing a similar thing
with edge lengths. The only difference is doing this little bit here
so it always keeps it between 0 and 1, either subtracting or dividing
it by the average or the maximum minus average.
Now node separation is sort of the least standard out of all these.
Here we use the concept of separating rectangles. So the idea is that
I have a node and I try to find the largest rectangle that contains the
node inside the bounding box that contains all the nodes. That doesn’t
contain any other node. So rather than just looking at the node that’s
nearest to it you are looking at this bounding rectangle because two
nodes might be next to each other, but may have a lot of other space to
other side. So this tries to take it into account for that.
Now here are some sample layouts that we get for all this. This is for
a graph with 55 nodes, 121 edges from the expansion library. Now the
first column is just the different initial placements. Random, as you
can see, is quite bad with almost 1600 crossings. But of course you
get no crossings here, but the other metrics are, especially edge and
node separation, are worse than they are with a random one. As you can
see like here, there are really compacted areas where a lot of the
graph is drawn.
Now with the Fruchterman and Reingold the first one is the
approximation. The next one is the exact and you see they are a
somewhat similar structure, but not quite the same. But generally you
have fewer crossings with the exact one. Kamada and Kawai are just
different layouts and what we have found in general, this is not really
effected by the initial layout. And we have a sort of similar thing
going on with stress majorization.
Now in terms of the aesthetics of just the placers all by themselves,
without doing anything else, we see that of course the random one is
the dark line where you get a quadratic number of crossings based off
the number of nodes. And you have far more crossings than you do with
the planar layouts which are 0. Now with minimum angle, the minimum
angle’s actually worse with the random one than it is with the planar
ones, so it’s not quite as bad. But the planar ones are worse than
just a pure really random layout, which doesn’t look all that great for
both edged lengths and node separation. And we see the same thing with
the other set of the three graphs in the library.
Now when we look at the base embedder aesthetics, this is using the
random placement, this is what’s typically done. We see several
things. Okay. So, the dark green line here is the FR with the
approximate. The dashed that’s also green is the exact one. This
purple one here that’s sometimes dashed, but sometimes looked solid is
stress majorization. And the orange one is KK.
Now in general, like especially with trees, Kamada and Kawai gets
virtually all the crossings. And it does fewer crossings with the
denser graphs and also with the real world graphs. And with the other
aesthetics it also has, and it’s is generally always the best, except
for this one case where the approximate version of FR is a little bit
better with the node separation with your purely random planar graph.
And the other three are similar.
Now, so for our results this is a somewhat different layout. See
before, this one is with the absolute values and this one is with
percent improvement, okay. So here we are talking about how, what is
the percentage of improvement or worsening? So for the first column we
see a lot of improvement in terms of crossings. So for both the FR
ones we are getting rid of a lot of crossings with the trees. And in
some cases for the between like the 20 to 40 virtually eliminating all
the crossings. Then getting rid of most of them otherwise. We get
about a 20 to 40 percent improvement otherwise; also even stress
majorization gets rid of quite a bit even though it doesn’t look all
that great. This is final result. But KK is not really effective.
It’s for the most part what ever variation sees, mostly noise.
Now the good thing that we see is that our other aesthetics are not
really adversely impacted. For the most part they stay the same. They
are not really worsening and sometimes in some cases were actually
improving the minimum angel a bit, which is interesting. But for the
edge lengths and the node separation, for the most part, they remain
the same with some noise.
So, FPP which is, so KANT is an improvement of FPP. FPP doesn’t do
quite as good as KANT. And so we see that even depending on what
planar drawing that you put in you get --. That can affect the layout.
So it’s even sensitive between these two because if you look, so this
is proffer here, you get a lot of crossing elimination initially with
KANT immediately. Whereas here not so much. And it doesn’t get up to
100 with FPP and Schnyder has similar results to these so that’s
interesting.
So in terms of what found was, well when we are actually just comparing
raw aesthetics, so KK isn’t really affected, but Kamada and Kawai and
is an expensive algorithm. It takes a while to run. And in our case
if we are doing the exact version of FRE plus this very cheap
preprocessing step it often times will run 20 times faster for larger
graphs in our set. And so the question then becomes, “Well how do
these two just compare in this raw comparison”?
And you see that in terms of crossings they do very, very similar. Now
this first graph might looks worse than it really is, but it’s just
going up to 4 so I mean its getting rid of most of the crossings
entries. So it’s very comparable in terms of crossings for these
graphs where KANT and FRE have a slight advantage over KK for the
denser graphs. It’s only worse with the trees. The minimum angle for
the most part is just slightly better with trees and for the most part
the same for the other two.
Now for edge lengths and node separation, then
better, it’s better across the board. So it’s
the other ones go down to .6. But still, this
algorithm to run KK and this is a much cheaper
get similar results with this preprocessing as
more expensive ones.
in this case KK is
consistently at .8 where
is a more expensive
algorithm to run. So we
you do with these other
So in terms of our conclusions we have several. We see that we can do
this linear preprocessing step that doesn’t really add much to the time
and it does have an effect upon the crossings; at least for the
[inaudible]. So for sparse graphs it does quite a bit better. But
even for denser graphs we see an improvement, which is the key. And
the most important thing is that the other aesthetics for the most part
are no adversely affected. So you are not doing this tradeoff that you
are doing initially with spring embedders where you are trading
[inaudible] for readability as much.
So we also notice that the multi-dimensional scaling is relatively
unaffected by planar preprocessing which makes sense given how it works
by throwing everything up into a high dimensional space and then
projecting it down. And we saw, as I was showing, that KANT and FRE is
competitive with KK, which gives some motivation for doing this.
Now in terms of future work, we have several things that we can do. So
one of the things of course is see, when we did this ODGF we just used
it out of the box. We did not do any messing around with parameters or
anything. So we could try to adjust the ideal edge length with what
you actually get as the average length, which might help some. And an
important thing with FR is, as I said, it can do this big initial
moves. And if we can adjust the cooling schedule so that it tries to
avoid these big moves, to an extent that’s going to introduce a lot of
crossings. That would be good.
We also really only went up to 100 nodes. These are still relatively
small graphs. And it would be interesting to see, you know, do these
results continue for very large N, you know if you go to 1,000 or
10,000. Do you continue to see this kind of improvement or is it just
initially? And, but I think even a more interesting thing to do is
that, well planar graphs are sometimes, but as in the case for ROME
they are only like 1/3 of the time for those. So we would like to be
able to process non-planar graphs. So we could extract a planar
subgraph and draw that first and see if that helps.
Now if we are drawing the planar subgraph’s and just drawing that then
you throw in the other edges. That can adversely affect those other
aesthetics. And also we just looked at these other aesthetics in terms
of edge length, node separation and angular resolution, but there is
other ones like asymmetry and, um, um, there are many other’s they are
just escaping me at this moment.
So, and I think one last other thing of future work and that will be
the end of my talk, is that we can maybe try to work with getting a
smarter force directed algorithm, kind of using the technique used with
[inaudible] and them. And try to get it so that we get one that
doesn’t introduce crossings as much and see how that works as well.
Okay, so thank you.
[clapping].
>>: Are there any questions for Joe?
>>: So when you apply a [inaudible].
>> Joe Fowler: Planar bedding?
>>: Which one?
>> Joe Fowler: Um.
>>: Especially for the [inaudible].
>> Joe Fowler: Yeah, we use the default one with OGF where it augments
it to a bi-connected graph and then picks a random one from that.
>>: [inaudible].
>> Joe Fowler: Yeah, yeah, we, we, just used and in each case we just
used the default. So we did not look at trying to pick better and
better embeddings and also to make one note in terms of our
experiments. We ran each one, each graph 10 times with 10 different
random embeddings. So we didn’t just pick one, we tried 10 different
ones. But we didn’t do anything special about picking those 10.
>> Okay, I have a similar question.
This FPP [inaudible].
>> Joe Fowler: Yes, yes.
>>: So you have to extend your graph.
>> Joe Fowler: Oh, yeah, yeah, yeah, exactly.
>>: And you can do it in different ways.
And we --.
Did you try that?
>> Joe Fowler: No, no, we, we did --.
>>: [inaudible].
>> Joe Fowler: Yeah, yeah, exactly, so that’s one reason why --.
>>: [inaudible].
>> Joe Fowler: Well I would think that with KANT it does a better job
of augmenting the graph initially.
>>: Yeah, because it’s not trying, it doesn’t, it’s not fully
triangular.
>> Joe Fowler: Yeah, yeah. And so that’s, but yeah, just to the point
of getting it to the point where you can even use KANT there is a lot
of different choices you can make there. So certainly augmenting the
graph would definitely help.
>>: Okay.
One more question.
>>: [inaudible] force directed methods.
Is there any theorem to prove?
[laughter]
>> Joe Fowler: Um, not at this point.
can’t --.
>>: [inaudible].
Not off the top of my head.
I
>> Joe Fowler: What?
>>: [inaudible].
>> Joe Fowler: Well, I am trying; I mean basically the idea is that
spring embedders are effective. The input is [inaudible] by our
processes. Yeah, so not, we are empirically trying to show that.
>>: [inaudible].
>> Joe Fowler: Possibly, if you really understood how --. You have to
really restrict the [inaudible], but yeah, possibly. It’s a good idea.
>>: Okay, thanks again Joe.
[clapping].
>>: And our next talk is by Thomas Blasiuss called Disconnectivity and
Relative Positions in Simultaneous Embeddings. And this is joint work
with Ignaz Rutter.
>> Thomas Blasius: Okay, thank you. As mentioned this is joint work
with Ignaz and it’s about simultaneous embedding with fixed edges where
the graph is not necessarily connected.
Okay. I want to start with the definition of the problem. We have two
graphs as input, having a common subgraph. And we want to find planar
drawings of each of the graphs, such that they induce the same drawing
on the common graph. So in this example we have this red graph and the
green graph. And both are planar. And here on the right we have a
simultaneous embedding with fixed edges where in particular, for
example, this edge here which is a common edge is drawn the same in
both drawings. And each of the drawings is planar, but we are allowed
to have crossings between red and green edges.
Okay. There is a nice theorem by Junger Schultz stating that we do not
need to care about the real drawing, but can deal with the embedding
only. Or more precisely these two graphs you want into two have a
simultaneous embedding with fixed edges; if and only if, they admit
planar embeddings that induce the same planar embedding on the common
graph.
Now what does it mean to induce the same planar embedding? There we
have to look at what embedding really means. And embedding consists of
two parts. First we need a consistent order of edges around vertices
and around the positions of connected components to each other that
need to be also consistent.
So previous results mostly ignore the right pod with the relative
positions completely and only deal with the ordering of edges around
vertices by either assuming that the common graph is connected, or that
it’s a forest. There is one result that’s somehow in between, at least
a little bit. And namely in the case where the common graph has one
cycle and then you have to also decide whether to put other connected
components into the cycle or outside of the cycle.
And we do the opposite to these approaches by ignoring the order of
edges around vertices and only looking at relative positions of
connected components to each other. And this is done by assuming the
common graph consists of disjoint cycles. And we will see that this
can be solved in linear time.
Okay. I am going to start with an overview. First of all we need some
kind of representation of the planar embeddings, of the set of cycles.
And we just orient the cycles arbitrarily. And then use pairwise
relative positions to describe the embedding.
So in this example we have the blue and the right graph cycle on the
same side, namely on the left side of the green cycle. So here these
two relative positions are left. Another example the right cycle is on
the right of the blue cycle so the relative position off the red cycle
with respect to the blue cycle is right.
If you have an assignment of left and right values to these relative
positions then we call this semi-embedding of the cycles. And of
course not every semi-embedding is also and embedding of the cycles
because we can, for example, not just put the right cycle to the right,
inside of the green cycle without changing any other relative
positions.
Okay. What we then do is we do not consider two graphs having the set
of cycles as common graphs. But we look at a single graph, a single
connected graph, containing the set of cycles. And then we show that
there is a data structure that we call the constrained cycle tree to
CC-tree for short, which represents all the semi-embedded of the set of
cycles that can be induced by an embedding of the graph G.
We further show the intersection of 2 CC-trees is again a CC-tree. And
this essentially solves simultaneous embedding with fixed edges for
this case because we just take the CC-tree of the first graph
representing the embeddings of the cycles with respect to the first
graph; and the second CC-tree representing the embeddings of the cycles
which can be induced by the second graph. And then we check whether
the intersection is empty or not.
Okay. So let’s start with the graph which is connected and contains a
set of these joint cycles. Now what are the embedding choices? For
example we can re-order parallel subgraphs. So in this case we change
the order of the green path with this larger component. And this
changes the relative position of these two cycles with respect to the
green cycle. And the nice thing is that this is the only possibility
to change these relative positions. So we get that this equation up
there always holds namely that the red cycle and blue cycle are always
on the same side of the green cycle.
Another way to change the embedding is flipping tri-connected
components. So in this case this component was flipped. And this of
course changes the orientation of the blue and the red cycles of all
cycles in this tri-connected component. And thus it also changes the
relative positions of all other cycles with respect to these cycles.
And again this is the only way to change these relative positions.
So we get these constraints there, mainly that if you look at the blue
cycle then the orange and the green one are on the same side and the
red is on the opposite side. And similar for the red cycle all other
cycles are on the same side no matter which embedding we choose for the
graph sheet.
And then we can also change the embedding around cutvertex and this may
also yield some additional constraints which are similar to that. And
what we can show is that these constraints are not only sufficient, but
also necessary which means the following. So the necessary means that
if we choose an embedding of the graph G and look at the embedding of
the cycles, the resulting embedding of the cycles, then this semiembedding satisfies these conditions. And the other way around, if you
take a semi-embedding and set aside these conditions then you also find
an embedding of the graph G that chooses this embedding on the cycles.
Okay. This essentially yields already a solution of the simultaneously
embedding fixed edges problem because we have bijection between an
instance of 2-Sat and all embeddings of the cycles that can be induced
by a connected graph. So this instance of 2-Sat is just because we
have a set of equations and inequalities between binary variables that
can take the values left or right.
The problem is that we have a quadratic number of variables because we
consider pairwise relative positions as variables. And the solution to
that is the CC-tree, the constraint cycle tree which I want to
introduce now. Here again are the constraints we need to satisfy. And
to construct the constraint cycle tree we start with the original graph
and take a minimal connected subgraph containing all the cycles. So in
this case we just remove these gray edges here. Then we replace paths
with single edges. So this path of length 2 is replaced by this edge.
And now we essentially have a tree structure. We have this orange
cycle connected to the green cycle, which is connected to the blue
cycle, and this is connected to the right cycle. And if you contract
the cycles to single nodes then we get in this case a path, or in
general a tree.
We will then use this tree or each half edge in this tree to represent
one decision. So I am just making an example, if you consider this
half edge here, or this edge connected to the green cycle, then this
represents the decision of putting the adjacent vertex either to the
left or to the right of the cycle. And in addition we will say that
the tree structure enforces that the whole subtree that is connected
over this edge is also put on the same side of the cycle.
Another example would be the decision made here. There we decided to
put the blue cycle either to the left or to the right of the red cycle
and all other cycles have to follow because of the tree structure;
because this whole subtree is connected over this edge. And what we do
then is we take the constraints we have up there, constraints, and
apply them to these decisions we can make in the tree.
So for example the first constraint up there states that the relative
position we choose here is the same as the relative position of C3 with
respect to C1, but there is not edge. So we just throw away this
constraint. And the nice thing is that, at least in this case, the
tree structure automatically enforces that this and this cycle are on
the same side of C1. Similar we don’t have an edge between C4 and C2
so we throw away this first equation, but for this inequality we have,
the decision we make here and the decision we make here needs to be the
opposite.
And what we can show is that the resulting tree and the set of
embeddings that are represented by this resulting tree are exactly the
embeddings of the cycles that can be induced by an embedding of the
graph. This means in particular that we didn’t throw away too many of
the constraints that we have and that the tree structure did not
enforce too many constraints that are not necessary.
Okay. So let’s state this theorem once again. And we get another
theorem namely that we can compute this constraint cycle tree in linear
time. Moreover the intersection as mentioned before of two constraint
cycle trees is again a constraint cycle tree and it can be computed in
linear time. And this directly yields that if you have two connected
graphs that you want into two with intersection graph is the set of
these joint cycles then we can test in linear time whether G1 and G2
have a simultaneous embedding with fixed edges by just taking the
constraint cycle tree with respect to G1 and the constraint cycle tree
with respect to C2, G2, and intersect those.
So, just one word to this thing here; you can probably imagine if the
underlying tree structure of these two constraint cycle trees we have
is the same then this is pretty simple, we just take the union of all
constraints we have on this tree. But if we have two different tree
structures then we need to do something more. We need to transform
some of the tree structure from one tree to the other tree. But this
is possible in every case.
Okay. So now we have this restriction there that the graph G1 and G2
are connected and we want to deal with disconnectivity. So we need to
deal with that somehow. And the bad news is that the CC-trees don’t
work for this case, but we get a more general result. Namely if you
have an instance of SEFE then we can always construct an equivalent
instance in linear time, such that both graphs are connected. And this
does not only apply for the case where the common graph is a set of
[inaudible], but for instances of SEFE.
Now of course the CC-trees can also be used to solve the problem for
more than two graphs if they all intersect in the same common graph
consisting of a set of pairwise distance cycles, because we can just
intersect an arbitrary number of CC-trees. And we can extend the
result to the case where the common graph consists of a set of
connected components, each with a fixed planar embedding.
In this case we have the problem that the decisions we make, the
relative positions, are not on binary choices because we don’t have
just left and right, but we have phases we have to decide where to put
the other components in. And in this case we need [inaudible] time.
Okay. So I want to conclude with a slide I had before and with an open
question which is in our opinion one of the main open questions for
simultaneous embedding with fixed edges. Namely can we deal with both
of the parts consisting that are contained in the choice of an
embedding at the same time? So can we at the same time enforce
consistency of relative positions and ordering of edges around
vertices?
Okay.
Thank you.
[clapping].
>> Alexander Wolff:
Questions for Thomas? Okay. Thanks again.
The next talk is given by Quan Nguyen. I am sorry about the
translation. The title is StreamEB: Stream Edge Bundling. And it’s
joint work with Peter Eades and Seok-Hee Hong.
>> Quan Nguyen: Good morning everyone and thank you Alex for
introducing me. My name is Quan. So before the talk I want to mention
about a big data, recently big data is something new. And big data
analytic is something real [inaudible] that people need in the
industry. And the four challenges with big data are that we have lost
volume, the velocity and the variety and also diversity. Today I am
going to talk --. My talk is focused on the first three, the volume,
velocity and the variety. For the diversity or the truthfulness or
reliability, later we are going to talk [inaudible].
So this is the outline of my talk. So basically the streamEB graph is
everywhere. And graph streaming is becoming popular. So now before
that talk we need to distinguish between dynamic graph visualization
and stream graph visualization. So for dynamic graph visualization in
system matters we focus on a quite limited number of static graphs and
[inaudible]. You can see G1, G2 and G3. Each of them can be
aggregated data from a yearly report, monthly report.
And for stream graph visualization we focus more on like the data is
very long dimension, it can be the size this big. But for this work we
only focus on the time dimension as very long. And the big data that
would do in financial activities and fly monitoring activities. It can
be millions of records and it can be stored in gigabytes.
So the real motivation for our work is that one. And the challenge is
for stream graph visualization is we want to be able to see the trends
and challenges over a time. And also we want to see and make a
[inaudible] of mental map. So that the user can see what went on. And
a recent survey by [inaudible] the control between readability and
stability, but for this work we focused more on the visual clutter.
For [inaudible], no matter what [inaudible] we are going to use we have
to solve the visual clutter problems. So this is the motivation of our
work.
And [inaudible] it is one of the reasons it’s a popular topic in the
information visualization community and graph drawing community. And
there are a few represented works. Before going to details of our
research I want to show you a movie. So here I am going to show you to
two types of animation, events by animations. One is with the static
layout that and the other one with a dynamic layout.
This is the simulation of the hijacking activities 11 years ago. And
for it [inaudible] represents a city and the edges representing the fly
connecting between the airports. And the color represents whether the
fly is, red meaning [inaudible] and green means [inaudible]. So the
hijacking activities happened around 8:00 AM to 9:00 AM. Then you can
see after the first attack the number of flies significantly dropped.
And you can also see the distribution around the US. This is after the
second attack. Okay, so here we are at the end. So about 9:20 it’s
almost shut down, no more flying. And it happened for more than half a
day and then it resumed around midnight. And then the next day they no
flied, I think one single fly.
And for the second animation I want to show you how the [inaudible]
framework can work for dynamic layout. And for this one I used a
circular layout. It’s a stop weight. And [inaudible] is a trader and
the connection and the trades between them. And you can see the
animation over time from the market stock. So when a trade happens the
active trader comes to the center and the bundling based on our
[inaudible] compatibility that I am going to introduce to you later.
So I will come back to --. So you already have some idea about what I
am doing. So now I am going to talk in detail about what is stream
edge bundling. We introduce it as StreamEB framework and also we
introduce two types of new compatibilities for stream edges. And also
we have introduced two types of stream bundling matters. And the
motivation is that we want to analyze big data, massive relational time
series in financial activities and flight monitoring activities.
So first of all I want to introduce the bundling pipeline. And
StreamEB is the cord of pipeline. And the important point I want to
make is how pipeline can handle dynamic [inaudible] from the dynamic
results. We can have the mapping again, that has not been previously
studied before.
Now so what is stream actually? In our model we study the stream as
the continuous flow of stream wraps, stream elements, and when we are
assessing one of the popular techniques in data mining, for mining
graph streams. In our study we studied two ways for window-processing
as sequence-based and time-based. And for each element the most
general [inaudible] is a node connected to a node at a given timestamp
with duration.
Duration is important for some applications, but maybe not. So for the
other applications for symbols like for flight monitoring system
duration is something important. We need to know when it departs and
the landing so that we can [inaudible], but for some other applications
like trades. A trade is a trade and normally we don’t to reverse the
trades that have already happened, unless in case you made some illegal
trade and you have to cancel. But it is very rare. In general our
model can handle those.
We introduce you to the compatibility metrics. The first one is
temporal compatibility. The basic idea is that for stream edge we have
the timestamp and the end time happening some duration there. And we
define several metrics to build the compatibility between them. It can
be based on a timestamp, the duration, the end time or the timeoverlapping. The idea is that we want to relate the stream edges
together so that we can do some analysis on that.
For neighborhood compatibility we also want to study some causal
relation between the edges. And that our neighborhood compatibility -. It’s kind of like we had the multi one dimensional data and we want
similar edges together based on the multi dimensional vectors.
For aggregate the final compatibility we aggregated the four
compatibilities, the temporal compatibilities, and the temporal
compatibility neighborhood, data-driven and spatial compatibility
together. And we can start building our bundling methods by this list
of aggregate compatibility. We introduce two methods, force-directed
and tree-based stream bundling.
The first one is force-directed stream bundling with dynamic layout.
The model extends the classic spring algorithm. We introduce a new
type of force; the bundle aware force. Previously we only had the
spring force, the repulsion force and some external force. Now we
introduce a bundle-aware force. And the idea is that the bundle
results can help us to make the layout nicer in terms of the bundles.
And the simple version simply extends the FDEB methods. And the idea
is that we integrate the new aggregated compatibility measures into
this. We also introduce some optimization in case we want to bundle
data, but the nodes had a fixed location. And we want to serve a lot
of computations. And we introduce something like a 2 step process, the
offline and the online.
For the offline step we do some re-computation of the compatibility and
the compatible edges. And then on the online step we just reused the
information that we already computed and then we set the running times.
The fourth method is tree-based stream bundling. We introduce doubleinterpolation process. You can read our paper on it and see. For
implementation we implemented on GEOMI framework and also I do it with
Neo4j graph database. The [inaudible] we want to analyze big graphs.
And here are some results that you can see. So we can compare from
8:00 AM, 8:30 AM, 9:00 AM and 9:20 AM, and the affects of the hijacking
activities on the flights in the US on that date. And you can see that
from 8:00 AM to 8:30 AM there is a significant dropped number of
flights and [inaudible]. And before a certain time it dropped even
more. And we see how the results look like using S-FStream EB
bundling.
It’s nice, but somehow it may introduce some artifacts. These two sort
of like re-routing like near the trees [inaudible]. And we see how our
framework can produce results for trading activities. The node
represents traders and the edges represent the connecting between them.
And this is using force-directed F bundling. The same layout and the
layout using multi-one-dimensional scaling based on the trading, the
frequency of the stock trades between the traders. And this is
circular, how it looks using tree-based. And this is circular using FF directed, with F-F directed layout as well, that you can see the
animation.
For performance, from what we studied it seems that S-FStream EB is the
farthest one because it saves a lot of [inaudible] without much
iteration. And also for our optimization method it also can reduce
that computation cost. But in general we need to do it more to make it
really [inaudible].
For limitations and future work, I am at [inaudible] currently where it
provides the flexibility, but also it requires the use of [inaudible]
to adjust the bundling parameters. And currently the number of
parameters is not small. And how to make the adjustment is based on
the experience to play with the tools and also they really need to see
--.
As far as future work we plan to interact with some semantic zooms and
so on. So we want to adopt some faster and more scalable methods so
that we can adapt to make analyzed big graphs and also we want to
analyze hierarchical data. For example [inaudible] data.
Okay, yeah, that’s the end of my talk.
[clapping].
>> Alexander Wolff: Thank you.
Thanks again.
Are there any questions?
No questions.