1
>>: Welcome to the final session of the Graph Drawing conference. I'm happy
to see that you're still here. We saved the best for last and it's these four
presentations. First speaker, Benjamin Bach.
>> Benjamin Bach: Thank you. Hello and welcome to my talk on interactive
random graph generation with evolutionary algorithms using our tool, Graph
Cuisine.
This work has been done with Andre Spritzer from University of [indiscernible]
in Brazil, Evelyne Lutton and Jean-Daniel Fekete from INRIA, France.
So this is Bob. He works for a big, huge company. And he created the
automated layout algorithm for the router networks. Bob's problem is or what
he wants is to get this paper in the next GraphDrawing for next year. And this
is just an image of a routing network.
So Bob's problem is that such routing networks contain a lot of sensitive
information in their topology. And you can imagine you cannot just hand over
such routing networks to everyone or just do usability studies with such
networks.
So but Bob wants to test his algorithm. So what he needs to do is to create
similar networks that have, let's say, the same topological properties as this
network and since you want to test different conditions, he has to change the
network slightly in order to test his algorithm and write his paper.
So what can Bob do? He can generate graphs if he cannot use this dataset he
has. And for generating graphs, he needs to generate graphs with particular
measures such as certain size and less size and more -- less clusters and so
on.
And then he needs likely to change these measures for each of the graphs.
Now, what he also wants is direct feedback on these graphs. So just generating
them and then waiting and have a look again and changing everything, he does
not want that. So usually when generating these networks, we need first a
generator. Once we have a generator, we need to know its parameters. In order
to get our properties that we want.
2
And in a second part of this generation, we need to know the parameters to
change in order to change our network. So if we want the networks bigger or
more clusters, less clusters such things.
Now let me explain how we do this with Graph Cuisine, which is an interactive
explore tive approach to graph generation. So we can generate graphs, we can
mimic data sets and once we mimic them, we can also adapt them. So you imagine
this, the image from the routing network in the first scenario. Now, this is
the interface of Graph Cuisine, and we already have imported the network into
Graph Cuisine so now it appears there in this one view.
And on the left side, Graph Cuisine had created some graphs that look like this
one and has several measures, has the same measures as these imported networks.
So how do we create the similarity? In this parallel coordinate plot, we have
one vertical line for each common graph measure. So in this case, we have the
node amount, we have the edge amount, we have density, diameter of these
graphs, and the white knobs here highlighted by red circles, those are the
measures of our imported network.
And the other lines in this coordinate plot, they represent the graphs Graph
Cuisine has created. And as you can see, they already converge towards the
import measure, the measures of the imported graph. And as I said in addition,
the user can already see the network, how they look like and if they are
actually the same for him.
At this point, we can say this is what we want and we export our graph so we
have a lot of graphs and we can test our algorithm. Second point, how to adapt
these measures. We can use this directly, we can use it in the parallel
coordinates plot by simply either moving the target measures and then we can
also lower the importance of each of these measures. So how important this for
calculating this similarity. In this case, we just [indiscernible] the width
of the colored bars.
After doing so in this case, we lower the amount of clusters we want to have in
the networks. We get networks with less clusters. And at this point again, we
can export our networks or we can further continue exploring our solutions.
So I was talking a lot about optimization and creating networks. So how do we
do it actually, because this is only the interface. There's some magic in the
background and this is why we need our evolutionary algorithm.
3
So evolutionary algorithms are optimization problem that model the problem as
an inverse problem. That is, first, we have a population of solutions which
are encoded in the chromosome. This is where pretty much the process as in
nature. So we have chromosomes that represent solutions, and then we select
chromosomes, we create new solutions, we have to calculate how well or how fit
these solutions are if they survive or if they do not survive.
And for graphs, you can imagine we have two generated graphs already, two
parents. We take them, we create a new child of them, which has
characteristics of both of the parents, and then there's a mutation as it
always happened. So to make a proper child. And as I said, the final question
is how to assess similarity or how to assess the fitness of this individual.
And in many cases, this target graph is either an imaginary graph the user
wants to create for his experiments, or it is one of the [indiscernible]
datasets.
And then by iterating over this optimization process, we approach our optimal
solution. Now, one problem is how to define similarity. Of course, we can run
the algorithm a lot of times. And then he might come up with a good solution
that is already pretty close, but similarities in the eye of the user in this
case. So the whole optimization problem turns into an exploration problem.
The user needs to explore his solutions. And this is where we need interaction
in this whole process. So it's an interactive evolutionary algorithm,
actually, that we use in this case. And interaction can be at several points
of this evolution process in the upper right corner.
So let me explain how this more abstract process is implemented in Graph
Cuisine. So, of course, we have a population of solutions which are a set of
graphs, and these graphs, of course, they are encoded in chromosomes. And
chromosome and evolutionary algorithms is simply a list of parameters and their
values.
So first, from these parameter lists, we need to create graphs. And this is
then a Graph Cuisine by using a pipeline of graph generators. So here in this
example, we have generated G1, which generates some star motifs. And then it
hands over to graph generator, G2, which introduces some edges and the graph
generator, G3 in other words some random noise. So in graph G3, we several
motif generators for particular motifs and we some, we call them noise
4
generators, but it's not negative in this case.
according to several laws, basically.
That create edges and nodes
So now we have our generators and each of these generators is controlled by a
set of parameters, of course. So, for example, we have a star generator that
has as input parameters the number of stars you should create, the degree the
stars would have and the variance in degree that because you don't want all the
stars to be the same, probably. Maybe.
And here, we make the link to the chromosome so each of these input parameters
for our graph generators are encoded in these chromosome. So, for example,
here we have a star generator, which has parameter one is the number of stars.
Parameter two is the degree of the stars, and the last parameter is the degree
of variance.
And then it just does what it has been told. So there are some other
parameters on this chromosome such as though two. They are more or less for
controlling the pipeline, such as the order of the generators, because they
might change, and whether they're active or not.
So once we've created the graph from a chromosome, now imagine our population
is around 50 chromosomes, we have around 50 graphs. We need to assess the
fitness of each of them. Each single one. And this is where we come back to
these common graph measures. Currently, we implement eight of them, but let me
talk about this a bit later.
So what we need to do is to get from each of the graphs that we generated the
common graph measures and then we apply a weighted fitness function, a weighted
difference function, sorry, to calculate the error, basically, of this graph.
And the lower the error is, the fitter the graph is.
So and this runs for several optimization cycles, for several generations
alone. And then the result is presented to the user. So this user can decide
whether he just continues with this optimization or whether he changes
parameters and so on.
And this is where the interaction comes in this process.
Now, there are five interaction possibilities in of great cuisine, where the
user can steer this evolutionary algorithm process. The first is, as I showed
5
you in the scenario to directly set its target, his targets measures. So he
weren't a graph of a certain size with a certain density with a certain amount
of clusters and so on.
The second one is since he sees the graph already there, he can just select
them, and the system then interferes with the measures that the user's most
interested in. So it's not that we keep these graphs particularly, but we keep
the measures.
The third interaction possibility, more or less, is that we have some templates
which are predefined sets of measures and predefined sets for our generators.
So if the user loads a template for uniform graphs, there will be -- the system
tries to create uniform graphs. So with just one component and very little
clustering coefficient, for example.
Because, yeah, often it's very hard to know even what is the combination of
measures to get a certain type of graph. And then, of course, he can enable
and disable certain generators. If he does not want to have any clicks in his
graph, he can disable this and see how the other generators work.
And finally, the user is able to steer the evolutionary algorithm itself,
because there are a lot of parameters in the system hidden that when we were
playing around with Graph Cuisine, we tried these parameters so they fit well,
but, of course, there's always space for optimization or depending on the
problem the user wants to solve.
So this is a set of complex parameters already there where ironically, we need
another evolutionary algorithm for that, but that's another story. So however,
the results we get, I don't say it's perfect, but it's worked.
So as you can see, this parallel coordinates plot for this first set of
measures that the users input, we get a solution. And on the left -- on the
right, sorry, there we have this is the diagram of the fitness of our
population. So the blue curve actually is the best solution in this current
population. And since it goes to zero, it means it's even better. So now,
usually it goes down. But sometimes it goes up. And when it goes up means
that the user has changed one of these measures. And you can imagine if the
year changed the density, the complete population gets less fit.
And then we have these vertical black bars.
This is always when the current
6
solution population is shown to the user, then he can decide to continue or to
change things so it goes up when there is something black and then goes down
again.
So this is, this is very important for evolutionary algorithm to test or to
prove that the algorithm works. So now we generate graphs for our group to
test, to use these graphs in experiments on graph visualization and visual
graph interfaces.
But there are open issues, of course, as in any system. So we need first to
improve the interface. Because if you might have noticed, there are several
dependencies between the graph parameters we use so you can adjust at the
density and the edge amount and the node amount of some operative values. You
will get either no result or a very bad result.
So this is more a question of interface design. How do we make the user know
that if he changes one of these measures, the others will -- they have
automatically also the change or maybe you can lock some parameters and so on.
Another issue is about parameter distribution. You want to have a certain
distribution of degree in your graph, which is currently not possible with
Graph Cuisine, not from the technical point. So the evolutionary algorithm can
handle it very well. It's more or less the interface issue again. So you need
curves that you want to adapt or you might need chain boxes or somehow to
talk -- to allow the user to specify the distribution he wants.
Of course, we want to put more visualization into interface or color nodes
according to degree or whatever so that it's even more easy for the user to see
the similarity, but in graphs or to spot the graphs you want.
But so far, the system is very extensible so we use a set of generators and a
set of measures and each of them is extensible. So you can create measures.
You can ask for other measures, and the set we implemented right now might not
be optimal so we're playing around to optimize the set of measures, which leads
to the last problem of calculation time.
Some of these measures,
coefficient for each of
need to do this for all
this is the bottle neck
such as calculating the clusters or the clustering
the nodes takes time and you cab can imagine if you
50 graphs in a population, this slows the system. So
of Graph Cuisine currently.
7
But it works fine for up to 100 nodes. It takes about one minute to create, to
go over five generations. So the system does five optimization itself and then
shows it to user.
And this, we want to optimize, I think there's a lot of space to get this time,
to lower this time, basically. And, of course, what we like the most, we get
feedback from actual users that use Graph Cuisine to generate their graphs, new
suggestions. So don't hesitate to go to our website,
aviz.fr/research/graphcuisine or send me an email and I thank you for your
attention.
>>:
Thank you.
Are there any questions?
Peter?
>>: I guess if you're going to use this for a scientific experiment, then you
need some sort of guarantee on its randomness, basically, that they think you
need to know something about the distribution. You need something provable
empirically or provable mathematically. Can you provide anything like that?
>> Benjamin Bach:
About distribution, you mean?
>>: Something, like suppose if you're looking for whole graphs that divide in
some sense into five clusters. You want to know that your distribution over
all graphs is uniform. Your choice is a uniform choice. And it's not clear to
me that this graph is reducing the evolutionary algorithm does anything like
that.
>> Benjamin Bach: If you go back to this picture, so I'm not sure if I got
your question properly, but for now we can show kind of distribution visually,
how the distribution of certain measures in the graph. So, for example ->>: The distribution of the graph's output, right? So that if -- you know,
there's a profile that you're aiming for. There might be, you know, a million
graphs that satisfy the profile. And you want to choose one with probability
[indiscernible]. Can you -- the probability that you get is exactly 100
million or even close to 100 million.
>> Benjamin Bach:
>>:
Offline.
I'm sorry.
We can talk --
8
>> Benjamin Bach:
>>:
I mean, I want to know.
Sorry.
Final question?
>>: In other experiment or settings, you would generate those graphs from some
distribution [indiscernible] your distribution is characterized by a few fixed
features, but nothing is said about what all the graphs that satisfy these
features, how you select from them. Are there any systematic biases that the
process that you propose introduces into the sample? [indiscernible] certain
way of going to the next generation.
>> Benjamin Bach:
So you mean --
>>: Let me put it this way. You have only these features specified. All of
the graphs that satisfy these features, may be many, but the ones you're
generating are only those that have another feature fixed to some specific
value. It might happen in the process and it would not be a good choice.
>> Benjamin Bach:
values.
>>:
Okay.
>> Benjamin Bach:
>>:
But in this case, there are graphs that fit exactly these
Sorry.
Was there one more comment from Alex, quick comment?
>>: Goes also in the same direction. It's another system that doesn't use
evolutionary algorithms. How would you compare your system to that system?
How would you tell which system is better?
>> Benjamin Bach:
>>:
[inaudible].
>> Benjamin Bach:
>>:
Since we focus a lot of interface, we can --
Yes.
So just by the graph output.
9
>> Benjamin Bach: We can hand in the same graph and then test how close it is
to these measures.
>>:
If it just returns the same graph again, it will be exactly the --
>> Benjamin Bach:
Exactly --
>>: You want something that's random that's close to it, but it could easily
satisfy that criteria by just returning the sample graph.
>> Benjamin Bach: Okay. I know what you mean. So this is exactly what you
don't want when you create -- yes. So here, you see it's not optimal. I mean,
there is -- I mean, this is exactly why you need the interaction. You don't
want just to set, to choose this graph that is your input graph and it's
definitely interesting to see how far we can get to the exact [indiscernible],
but here we do not encode the topology of the graph directly.
>>: Okay.
Suk.
We have to stop.
Thank you.
Let's go to the second talk, Andrew
>> Andrew Suk: So okay. So I'd like to talk about some density or Ramsey type
theorems for intersection graphs of T-monotone curves and I'll define what this
word T-monotone means in a minute.
So these theorems were motivated by three pretty closely related problems in
graph drawing or in topological graph theory. So just as a reminder, a
topological graph is a graph drawn in the plane where the vertices are
represented by points and the edges are represented by curves connecting the
corresponding points.
We say a topological graph is simple if every pair of edges have at most one
point in common. So here's an example of a topological graph, but it's clearly
not simple because these two red edges here have more than one point in common.
So these three problems in graph drawing are about simple topological graphs,
and in simple topological graphs, every pair of edges essentially looks like
one of these three pictures here. So either they have a common end point or a
common interior point, which is known as crossing, or they simply have no
points in common, like over here.
10
So the first problem that I was interested in, in graph drawing was this
problem here, which is known as a Thrackle conjecture, which Andreas mentioned
just a little bit ago, said states that every N-vertex topological graph with
no two disjoint edges has at most N edges.
This conjecture is still open, and it seems pretty tough and as Andreas
mentioned, this is currently the best known upper bound. But if you assume
that your edges are joined with segments or, generally, X-monotone curves, then
the conjecture has been proven to be true. So Erdos proved this several
decades ago, and somewhat recently, Pach and Sterling proved this for
X-monotone curves. And roughly, around the same period, several other people
have also proved the Thrackle conjecture for the X-monotone case.
So the second problem is kind of a generalization of this problem here, chase
question of -- which is a conjecture due to Pach and Toth. So they conjecture
that every N-vertex simple topological graph with no K pairwise disjoint edges
still has where K is fixed, still has at most a linear number of edges.
This conjecture is still open. And the best known upper bound is due to Pach
and Toth, who got a pretty good bound. So they got N poly log N, where the log
has this 4K minus 8 in the exponent.
But again, if you assume that your edges are drawn with segments or, more
generally, X-monotone curves, then this conjecture is true. And this was
proven by Pach and Torocsik back in 1993. In their 1993 paper, they proved it
for segments, but the argument easily generalizes to X-monotone curves.
So if you look at this Pach and Toth theorem here, basically, it says that if
you have an N-vertex simple topological graph with more than this many edges,
then you can say for sure somewhere there's going to be K pairwise disjoint
edges. And so if you have a lot of edges, you would expect to find a large
subset of pairwise disjoint edges. So the third conjecture is due to Pach and
Toth is that every N-vertex simple topological graph that is dense has a
polynomial number of pairwise disjoint edges. So basically, there exists a
delta that depends on the hidden constant here such that the graph should have
N to the delta pairwise disjoint edges.
The best known lower bound is due to Fox and Sudakov, who showed that they can
find roughly law to the 1.02 N pairwise disjoint edges. So this problem is
pretty wide open. But again, if you assume that the edges are joined with
11
segments or more generally X-monotone curves, then again by that same paper,
this conjecture is true and this was shown by Pach and Torocsik.
So these three problems are obviously pretty closely related. Oh, and just as
a quick note, in case you're thinking that maybe this conjecture is kind of out
there, there is some evidence that this conjecture should be true. So last
year, I was able to show that a complete N-vertex simple topological graph does
have a polynomial number pairwise disjoint edges. So roughly N to the
one-third.
But the proof does not generalize to dense graphs.
So these three problems are closely related. They are all still open, but they
have been all solved for X-monotone curves, but they're all still own for
two-monotone curves. So when I say two-monotone, I mean an X-monotone curve
that can turn once. The reason is basically all the X-monotone arguments
basically fall apart in this case.
And so they all fall apart for T-monotone curves. So a curve is, just to be
clear, T-monotone if its interior has almost T minus one vertical tandem
points. So a one-monotone curve is simply X-monotone. Here's an X-monotone
example of a four-monotone curve because its interior has three vertical
tangent points. So it's like the union of four X-monotone curves.
So one of the main results I was able to show is that basically, I was able to
say something about the second problem. So I was able to show that if G is an
N-vertex simple topological graph and its edges are drawn with T-monotone
curves where T is some constant, let's say a thousand, then if G does not have
K pairwise disjoint edges, then the number of edges -- well, I still have an N
poly log N bound, but the exponent now has this order of log K in the exponent
and C of T is some constant that depends on T.
So just recall this was the Pach and Toth bound. So the improvement is
basically on the order of K. So actually, when K is small, like three or four,
the Pach and Toth bound is not only better, but it's also more general.
But when K is large, this bound is stronger than this one. And since this is
logarithmically in K, this theorem immediately implies something about dense
graphs. So as an immediate corollary to this theorem, I was able to say
something about the third problem. So I was able to show that if G is an
12
N-vertex simple topological graph, again with curves drawn with T monotone
curves with some constant T, and if your graph is dense, then G contains almost
a polynomial number of pairwise disjoint edges.
So basically, N to some constant that depends on T divided by log log N
pairwise disjoint edges. So just recall Fox and Sudakov showed pretty much log
in, but pretty much their theorem is more general. And just recall the goal is
to show that there's polynomial.
Okay. So this theorem here, this theorem on the improvement of the second
problem. So this theorem here basically follows from this somewhat technical
two color theorem that says the following. So if R is a family of N red
T-monotone curves, where T is some constant, say a thousand, and B is another
family of N blue T-monotone curves, such as R union B is simple, which means
that basically every pair of curves have at most one point in common, then the
claim is that there exists subsets R prime and B prime that are very large.
They are an epsilon fraction of the family. So epsilon is some absolute
constant such that either every red curve in R prime crosses every curve in B
prime, or every curve in R prime is completely disjoint to every curve in B
prime.
So there's this two-color theorem might sound somewhat familiar because it has
been proven for other cases. So in particular, Pach and Solymosi proved this
two-color theorem for segments, and Alon et al. Proved it for semi algebraic
sets in RD. And Basu proved it for definable sets belonging to some fixed
definable family of sets and then no minimal structure.
So these three proofs here, they're actually all pretty similar, because they
heavily depend on the fact that these geometric objects that they're dealing
with have bounded algebraic complexity. They're not very complicated. You can
easily express them with some Boolean expressions.
And so they're pretty similar and because they heavily depend on that fact, you
can't just transfer these arguments and prove this two-color theorem. So you
would have to do something different. But these T-monotone curves can have
arbitrarily large complexity.
So this is actually the first time this two-color type theorem has been proven
for a class of geometric objects that can have arbitrary large complexity.
13
So with this two-color theorem and plus Szemeredi's regularity lemma, you can
get this density theorem, which is the title of the paper, and I guess it's
kind of like the main theorem. And then what this density theorem, you can
prove this result, the improvement of the second problem on the maximum number
of edges with no K pairwise disjoint edges.
Okay. So I will just quickly sketch the proof of this two-color theorem,
because it's actually pretty simple. So I just restated it there for your
convenience. So suppose we have this N red T monotone curves in the plane,
where T is some constant, say a thousand and we have these blue curves in the
plane and the whole thing is simple. So we start by -- so for each red curve,
we'll call one of the end points the left end point. It doesn't matter which
one.
So we look at the left end points of each red curve, and we look at these
points in these blue curves. If I randomly sample C blue curves for some large
constant C, and if I apply a trapezoid decomposition of the plane based on the
C curves, so what I mean is at every end point, I'll draw a vertical line, and
at every vertical tangent point, I'll draw a vertical line and these lines will
go up either to positive/negative infinity, or it will go up until I hit some
other member in the sample.
So when I do this decomposition, because these curves are T-monotone and T is
some constant and it's just sample the constant number of these curves, this
decomposition, so I have decomposed the plane into at most a constant number of
cells. There's only -- there's no so many cells here.
And because I did this randomly, each cell, like let's say this one here, has
the property that with very high probability, N over 2 blue curves will not
intersect the interior of this region here.
And this is true for all regions. So since there's at most a constant number
of regions, and I had end points, one of the regions must have a lot of points
because pigeon hole. So let's say it's this one. So what happened was
basically, you know, what I did basically was I found a region R that contained
a lot of points and a lot of blue curves, some positive fraction of them are
completely disjointed the interior of R.
So now if I just look at these blue curves and the remaining red curves, the
ones with left end points in this region, I still have a lot of red curves left
14
and a lot of blue curves left.
So now, if I do the same thing with the right N-vertex points and the blue
curves, if I do exactly the same thing over again, I'll obtain another region,
R2, such that each red curve will have one end point in R1 and another end
point in R2 and there will still be a lot of red curves and I'll still have a
lot of blue curves left, some positive percentage and these blue curves will
not intersect the interior of R1 and R2.
So now I'm going to do the whole thing again, flipped with the colors. So
basically, I'm going to do the whole process again with the end points of the
blue curves and the red curves. And when I do this whole process again
flipped, I'll obtain two more regions, R3 and R4, such that each remaining blue
curve will have one end point in R3 and another end point in R4. And these
blue curves will be disjointed interior this R1 and R2. And likewise, each red
curve will be disjointed the interior of R3 and R4. And I'll still have a lot
of blue curves and a lot of red curves left some positive percentage of them.
So the point is that I kind of have this nice structure here. I have
somewhat -- some control and so now basically, doing some case analysis, curve
argument like the curve has to go this way or that way, you can argue that with
this structure, there's a lot of either a lot of blue curves, disjoint to a lot
of red curves, or there's going to be a lot of blue curves crossing a lot of
red curves. And that's the end of the proof.
Okay. So if you think about that sketch proof that I just gave, I didn't
really use that T-monotone condition much. The only part I used the T-monotone
condition was when I did that trapezoid decomposition. And so my point is that
if you don't like this T-monotone condition, if you find it a little bit
strange but you like these types of problems, then you might be interested in
this problem here. Because if you can solve this problem, then I think you can
obtain the same results that I did without the T-monotone condition. Or at
least you would get close.
So the problem is, suppose you have n points in the plane, and you have a
family F of n curves such that, you know, F is simple, every pair of curves
intersects at most once. Then can you find a region, R, that contains a lot of
points, some positive percentage of them, and such that this are region R, the
interior is disjoint to a lot of blue curves.
So this is the open problem.
Some epsilon n fraction.
If you think this
15
T-monotone condition is kind of a nice relaxation, then maybe perhaps you might
be interested in proving the Thrackle conjecture for two monotone, because this
is still open. Or you might be interested in this color problem, which is
pretty nice. So the coloring problem is that if you're given a family of two
monotone curves in the plane, such that there are no three pairwise disjoint
members, the question is can you color the non-intersection graph with the
constant number of colors. So basically, I want to know if the
non-intersection graph of these graphs is kai bounded, basically. And this is
still open.
And again, if you assume these are segments or X-monotone curves, then the
chromatic number of the non-intersection graph is bounded. So it is true for
segments or X-monotone curves, but it's still open for just two-monotone.
And just as a quick note, I guess, the dual version is not kai bounded. So the
intersection graphs of, say, segments, is not bounded by the -- the chromatic
number is not bounded by some function of its click number. And that's it.
Thanks.
>>: Are there any questions? No questions? All right. Thanks again. We
proceed with talk number three of this session, the second to last talk of the
conference by Gabor Tardos.
>> Gabor Tardos: So thank you for staying 'til the last session. Just two
more talks and you are done. Anyway, so I'm here to talk about geometrical
problem of visualization, but it's not exactly graph drawing. So the setting
is that you have an arrangement of -- so you have a big map, for example, and
you want to put dots on all the places where I don't know, important people
that born or something. And you want to arrange it in such a way that as much
of this is visible as possible, but these dots are overlapping so I mean, you
have to come up with a stacking order, like which comes from the top and which
remains on the bottom and, of course which is this that is higher up, they're
obscuring the lower ones.
So there isn't too much that you see from particular disk here. So how much
you see in total in area that kind of independent, of course, of the ordering,
but maybe a better measure is how much of the parameter of the disk you see. I
mean, how many -- what is the length of the lines that you see. You want to
arrange them in such a way that this is biggest.
16
So again, the setting is that you don't move these disks. The disks, I mean,
for this talk, these are all unit disks or disk of the same size. Of course,
you can ask the same question for disks of different size or other forms. For
this talk, they are all unit disks and the position of the disks are fixed.
The only thing you can choose is an ordering, like a stacking order which comes
on top and which comes on bottom and you want to maximize the visible
parameter.
And for this talk, we are looking for the worst case instances, like how much
you can absolutely guarantee. So there are N disks then I can absolutely
guarantee wherever they are, the best stacking order will make sure that this
amount or that much of the parameter will be visible.
You may say that it's not very realistic if you want to visualize dots on the
map, they usually don't -- I mean, not all of them are intersecting or
overlapping, and usually they are kind of more scattered around. But just
working with this version, the worst case setup is good because that gives you
relevant results on a more realistic setup and it's not the number of disks.
All of them overlapping. But there is like a bound of, at most, three of them
overlapping. I mean, just using this result as a black box, you can come up
with the results on the more realistic setting.
So this is -- oh, by the way, so this talk is on joint research with Janos Pach
and Gabriel Nivasch and we were following footsteps of Cabello, Haverkort,
Speckmann, who followed this problem first, and they came one this very simple
argument that if you have N disk, then [indiscernible] parameter will be
visible if you do it right, and there is a very simple argument for that. You
can find some subset of the disks that formulate a monotone sequence. So you
can arrange them in such a way that both the X and the Y coordinates are
monotone in that sequence.
You put them on top in that sequence, and at least one quarter of the parameter
of each of them is visible. And you don't care about the rest. Maybe you put
the rest of the disk below all of these. Then you can -- so you have, yeah,
you have this [indiscernible] end as the lower bound.
And they asked if -- well, root ten is very weak. Maybe you can do actually
constant fraction of all the parameters visible. That would be much nicer.
And now you can define how much. FN is the maximal visible indicator for the
worst case point set. But for the best stacking order. So whenever -- or this
17
set, whenever these are given, then you find a best order to stack them.
So this is what we were working on. We strongly believe that none of these two
bounds are tight, but we couldn't prove that you can do better than square root
of N. We can prove that you can, for some set of this, you cannot do a linear.
So we could at least answer this question.
And so before I give you anything more about this problem, I start with the
reformulation. I mean, this is the last slide that I have that has disks on
it. So instead of disk, we will turn the whole problem into a problem about
angles.
So first observation is that you have two disks, you bring them together, then
whichever is higher up, you cover strictly more from the lower disks. So not
just more in terms of lengths of the parameter, but actually the set that is
covered is a super set here.
So if you are looking for a very bad arrangement of this, if you put all of the
disks much closer together, so instead of the points at P, you look at the
points at epsilon P where epsilon is something small, it's an even worse
configuration. And you're working for the worst consideration you can actually
consider this linear when epsilon goes to zero.
And then you do that suddenly, I mean, this is all about angles. It turns out
that this limit how much contribution a given disk is giving you is very easy
to formulate. So this is [indiscernible] is the limit of the lengths of the
parameter of one of your disks, how much is visible, the limit of that.
And that turns out to be zero if that center of that disk is within the convex
hole of the higher up disk that will then eventually obscure the entire disk.
And otherwise, I'm sure this is too low for anybody to see this picture, but if
you have this point on the boundary, on the convex hull of the higher up
centers, then what you are looking for is the external angle of the convex hull
at that point and so this [indiscernible] the angle, external angle is exactly
how much you will see.
And if you see this picture, so there is another disk somewhere along this
line. So as it comes closer and closer, it will cover everything except, I
mean, eventually it will cover half the parameter here. And then other disk
coming from here covers another half here and only in this little angle remains
18
that will not be covered.
So basically, the reformulation of the problem is a simple one. You don't have
disks. You have a set of points, a finite set of points in the plane. You
want to order them in such a way you start with just one point and then you add
points and then each and every time you add a new point, you look at the angle
of the convex hull at that new point.
If that new point happens to be inside a convex hull, that's really bad, then
you don't have any contribution there. Otherwise, your contribution is the
external angle, and the new point and you want to arrange the point in such a
way that some of these external angles is as much as possible and the question
is how much can you guarantee to be the sum of the external angle.
So that's the next equivalent formulation without disks.
result.
And now comes the
We have results for dense sets. So at a set of points, so this is scale
invariant at this point. So dense means that, I mean, like a grid, a set of
grid points, like a square root ten by square root ten grid is dense. What I
mean by dense is simply that you look at the smallest distance between two
points and the largest distance between two points and the ratio of these two
is as small as possible. So it can be as small as constant times square root
of N. It obviously cannot be smaller than that.
And if it's that small, we call that the points that is dense. And for dense
point sets, we figured out kind of exactly what happens. Turns out that there
is no good arrangement that would give you a linear visible parameter or the
sum of external angles. It's always N to the three quarter at most, and there
are point sets that achieve that. So it's N to the three quarter. It already
answers is it cab you always have a stacking order with linear visible
parameter question. No, you cannot. For any dense set, this will be less. It
will be at most N to the three quarters.
However, we were looking for the worst case set. So, I mean, this is much
more. This just says that for every dense set, so how about the worst case
dense set. So if you are looking for the worst case dense set, it happens to
be the grid where this exponent of three quarter goes down to two third and you
cannot go lower than N to the two third for dense sets. This is the worst is
case really the grid.
19
Another way to formulate is for dense sets, the maximal visible parameter is
between N to the two third and N to the three quarters and both bounds can be
obtained by dense sets.
And [indiscernible] the first [indiscernible] is this FN, the upper bound is
now N to the two-thirds. The grid gives you this upper bound. The lower bound
we couldn't touch. Unfortunately. I strongly believe that it's N to the two
third. That actually, if N equals the N to the two third and for the following
reason. I mean, it seems that a dense set is really bad in terms of visible
parameter. You never can get a linear visible parameter out of a dense set.
It seems that dense sets are bad. And but if there are worst sets, worst than
N to the two-thirds, then it's not dense. It's, I'm saying, other than dense.
So, I mean, at least for me, it's argument that maybe N to the two third is the
truth.
Okay. So I plan to give you the proof or at least a sketch of one proof and
that's for theorem one that gives you the first known linear [indiscernible]
sub Lynn-year bound. If you have any dense set, no matter how you choose the
stacking order, you will never get more than N to the three quarters as the -well, total visible parameter or the external relief. What I'm interested in
is the sum of the external angles as you increase the convex hole by adding the
points one by one.
And the main idea of the proof is to look at the parameter of the convex
source. So you start with one point, it has parameter zero. You add points,
the convex hole gets bigger and bigger and the parameter increases. But it
doesn't increase too much. So the point is that it starts with -- so while I
said it was dense so we can scale it so that the minimum distance is one. The
maximum distance is around square root of N. So at the very end, where you
take the convex hull of all the points, then it still has diameter around
square root of N. So the parameter is also order of square root of N.
So it starts with zero and it gets to square root of N, and there is a relation
between how -- so this S sub I is the parameter of the convex hull of the first
I points and it turns out that how much it grows really depends on this
external angle. So this is a little bit of elementary geometry to do here.
The point is that this is your new point here, and you know that in a radius of
one around it, there is nothing in the old convex hull. The minimum distance
was one and that's enough to prove that the new convex hull is, well, it can
20
only increase, of course. It will never decrease. But actually it does
increase by something depending on the external angle. Actually, proportional
to the square of external angle. And that's enough to give this three quarter
bound. So that's basically the proof.
This can be achieved by a very simple construction. You just take this grid,
basically, I mean, it's a regular square root of N of them in this fashion and
you order them inside out so you go around this circle inside out and it's just
a computation. I mean, simple computation gives you that this actually gives N
to the three quarters so you can do that. For the other two theorems, of
course, I will be much -- give you much less details. But there is some
similarities here.
So for theorem one, the proof idea was a parameter of the convex hull and it's
nice to know that the parameter is actually the integral of the length so you
have some convex object and the parameter can be computed by projecting this to
a line, measuring the length of the projection and integrating that around all
possible direction. It's very nice observation. And the next observation is
that if you start with the grid, then not all directions are created equal.
There are some important directions that are close to some sort grid vector,
and -- oh, okay.
And those show grid -- I mean, if you instead of just integrating, I mean, you
constantly put more weight on that, then you get a better bound, N to the
two-thirds and there is a connection between the second and the fourth. I
mean, the second theorem is that, says that there is this construction with a
concentric grid-like construction from inside out, you do a clockwise like
thing and that's a good construction. And last theorem says that for any dense
set, you cannot do -- I mean you can do something very nice, and it's a
random -- I mean, you just put this random grid on your set and pretend that
it's a grid. You just put the grid on the set and pretend that the whole set
is grid-like.
And, of course, note that the exponents are different so you lose something.
But you don't lose that much.
And finally, a related question that might also be interesting, but was already
sold by all these people, if you are not concentrating on the sum but you want
to have from each disk you want to see at least some amount of visible
parameters to get and there's a very simple greedy algorithm so the greedy
21
algorithm that you can come up with that works and that gives you optimal
results, and the answer is this 2 pi over N. And this is still open where the
optimal thing is if your point set is not dense.
So as I mentioned, I strongly believe that it's N to the two-thirds.
not square root of N. But I can't prove anything. Thank you.
>>:
Okay.
Thank you.
Certainly
Are there any questions?
>>: Is there anything known about how hard it is to compute the optimal
[indiscernible]?
>> Gabor Tardos: So as I said for this related question, it's a very simple
greedy algorithm. Gives you the optimal. And for the original question that I
was speaking about, I don't know. I had some conjectures of what algorithm
would be optimal and it wasn't. So I just, I just don't know.
>>: A question. Suppose you have a collection which is dense. And we
formulate the problem, which means I allow to move the original points, not to
get better results. And then measure how much I have to move the points.
[indiscernible].
>> Gabor Tardos: Yes, I mean, all I can say, it's a nice problem. Going back
to the -- I mean, map visualization thing, it might be relevant. If you cannot
visualize it exactly where it should be, maybe you should move it. We didn't
consider that.
>>: More questions? Thank you again.
the honor is for Eric Fusy.
And the final talk of the conference,
>> Eric Fusy: So this is a joint talk with my colleague, Luca Castelli from
Ecole Polytechnique and Olivier DeVillers from [indiscernible] in France. And
it will be about the very well studied topic of planar straight line drawings.
So first, very briefly recall that we are given, in the plane, we are given a
plane graph and want to have a representation, planar representation with edges
as segment. And so there are some classical algorithms like the first one, of
course, everybody knows is from Tutte with a spring-embedding principle.
And more recently, there have been two classical algorithms that gives
polynomial grid size. The first one is incremental by Defraysseix, Pach and
22
Pollack. So I will cite it a lot. So I short it to FPP algorithm.
second one is by Schnyder based on the face-counting principle.
And the
So in this talk, I will not draw graphs in the plane. So not plane graphs, but
graphs on two surfaces, the cylinder and the torus. And in each case, I will
give periodic straight line drawings algorithm. Planar periodic straight line
drawing.
So I start with the cylinder.
take out two disks. So it can
be equivalent to an annulus if
also [indiscernible] by taking
sides. Okay?
So a cylinder is a topological ridge where you
be either represented as a -- sorry. So it can
you project it flat into the plane. But again,
your square and identifying the two vertical
So here is a continuation of the cylinder. Here it is the annular
representation. And here it's periodic representation, okay. So why periodic?
Because if you take this square and make copies and place them from left to
right, you get a drawing this is periodic in X, okay?
So now, for the torus, it's similar, but you now identify a vertical size and
also a [indiscernible] side. So now again, you should have the graphs on the
torus and so we could get the flat torus here. Again, if you make copies, you
will obtain a periodic drawing of your graph. But this time, periodic both in
X and in Y. And again, we are interested in finding efficiently straight line
periodic representation of graphs on the torus.
So about what is known. So the first algorithm to do that has been given by
people from Winnipeg. I think it's incremental worst case analysis. So then
the second one is, adapts that algorithm to the torus and also this was in a
paper by [indiscernible]. And very recently, Goncalves and Leveque extended
Schnyder algorithm to the torus. So they obtained a grid size which is
[indiscernible].
So now about the overview and the main result. So in the first part, I will
recall the FPP algorithm for plane [indiscernible] and also give a slight
reformulation that is very convenient for us. With this [indiscernible], we'll
be able to extend the algorithm to the case of cylindric triangulations to
obtain the X [indiscernible] drawings and by a simple reduction from the torus
to the cylinder, we will also be table to get periodic drawings for
triangulations and the torus.
23
So about the grid size, it's not completely linear, so the width is height, but
the height is linear times the graph distance between the two boundaries. So
this is for the cylinder. And for the torus, the height is bounded by N times
the length of the shortest non-contractible cycle. Non-contractible means you
cannot shrink it to a point.
So these are the main results. So I trust even if many people know it very
well, I will recall the FPP algorithm and also give a reformulation of one
step.
So the first ingredient is [indiscernible] of canonical drawing for planar
triangulations. So it's a shelling order. So you have the [indiscernible]
match and at each step, you take a vertex in the top boundary, but not an
[indiscernible] of the [indiscernible] match, and you take it out of -- you
[indiscernible].
So you do it at each step so you choose a vertex in the top boundary, and take
it out. So you have to be careful this that vertex is not incident to a
[indiscernible]. Otherwise, the boundary would not remain a simple cycle.
And then you label the vertices from here there are seven vertices. Not
incident to the bottom edge. So you represent from seven to one until there
just remains the bottom edge, okay.
So it's a very well known notion. And something important for the FPP
algorithm is the notion of primal tree associated. So for each vertex, which
is inside the outer triangle, you have a red edge directed throughout its
neighbor of largest label, okay. So it's easy to [indiscernible] that it gives
a tree. This neighbor is also the vertex which shelling made this vertex
appear under a boundary.
So this is for the classical formulation of the FPP algorithm. So for the
reformulation that we will use, there is something important is the notion of
dual [indiscernible] tree so we are [indiscernible] to the primal tree and it's
now use classical duality for plane trees where so you put the vertex in each
phase and when two adjacent phases share an edge that is not in the primal
tree, you put a blue edge which is in the dual tree. So it's well known that
it gives spanning tree of the dual graph.
24
Okay. So before I describe the FPP algorithm, something important is that if
you take the vertices in increasing order, it gives a way to constrain our
triangulation step by step, starting from the bottom edge and adding vertices
one by one.
So, for instance, we got GK as the graphs formed by E and the first K vertices.
And so GK, so here G5 is obtained by adding a new vertex that we sort of had
and you can see that it covers a part in the graph G4, okay. So it's always
the addition of the new vertex, K plus 1. So K, say, covers a part in the
upper boundary of GK minus one.
So now we have the tools to define -- to say how the FPP algorithm works. So
say at each step you have a planar drawing of so here GK minus one. So it's a
generic step with the bottom edge [indiscernible] and the top edges of the
upper boundary are [indiscernible] minus one.
So when you want to insert the vertex K to the drawing and keep a planar
drawing. So what you want to do is essentially to insert this hat as a sort of
straight hat with this edge of one and this edge of slope minus one. So the
point is you do that, you see that this green edge will overlap with this edge.
So what you do is you shift step to make the slope of the green edge smaller
than one and the slope of the blue edge larger than minus one. So you just
shift the vertices here on the left by one and the vertices here on the right
by one to the right.
Okay. So and then you can insert K as a straight hat and you will not have
overlap problems with these edge joints. So what I didn't say is what you do
with the vertices inside. So actually, you might also shift them according to
the descendancy. So you look at the ancestor on the upper boundary and
[indiscernible] then you shift the vertex inside, okay?
So and by simple [indiscernible] argument, you can say that it remains planar
at each step. So here is an execution on an example. The weights increases by
two at each step, and you get planar drawing with linear width and height.
Okay. So now about the slight reformulation that will be very convenient. So
it uses the dual tree. So the step which we formulate is the shift step, which
we move to make the slope of this green and blue edges smaller than one
absolute value.
25
So instead of formatting as a shift, we use a more local formulation with a
dual tree. So as you can see, there is a path in the dual tree starting from
the edge dual to this green edge. What we do is just we insert this
[indiscernible] of width one along this part. It exactly is the same as
shifting by one the vertices on the left and then the descendant for the primal
tree.
So because this is the power edge, the sub trees on the left from the left -right sub trees on the right, okay. So it's just a reformulation. So we do
the same to make the slope of the light blue edge larger than minus one, and so
we insert the next vertex as a hat. So it was just a reformulation of the
shift set, but it will be convenient to extend the algorithm to the cylinder.
Okay. So now I can talk about the cylinder. So I'll explain how we can
explain this FPP algorithm to this setting. So first ingredient of the FPP
algorithm is the notion of canonical ordering. So this shelling order.
So first to define the canonical ordering, it's going to take the annular
representation so it's the triangulation of the cylinder. So the bottom
boundary becomes the outer boundary and the top boundary becomes an inner
boundary.
So in the plane case, we -- the base case is when you, at the end, you just
have the bottom edge and that is set, you shed a vertex on the upper boundary.
So here, what plays the role of the bottom edge is the outer cycle, and what
plays the role of the upper boundary is the inner boundary.
So which means at
Again, to make it
remains the outer
chord incident to
chord, toward the
each step, we want to shed a vertex in the inner boundary.
work, this vertex [indiscernible] and we do it until just
cycle. So there is a technical condition that there is no
the outer cycle. Otherwise, the area that is outside of the
outside, could not be visited.
So it works only under this condition, okay. So now we have a notion of
canonical ordering, which gives away to a [indiscernible] this triangulation
step by step in incremental algorithm. So there also is the notion of primal
tree. So now it's a primal forest with the roots on the inner boundary, and
there is a notion of dual, at this time, forest where actually you have to see
we put the vertex in front of each boundary edge.
26
So it's, now it's a forest, but it will work the same way.
planar case, we have to say how generic step would work.
So now similar to a
So now that we take [indiscernible] of the cylinder, we have a cylinder. So as
a standing cylinder, which is like the [indiscernible] representation, where
you physically identify the vertical sites. Okay. So imagine we have already
a crossing [indiscernible] drawing of GK minus one with this plus one minus one
slope condition for the upper boundary, and we want to insert the
[indiscernible].
Then we do the same as the reformulation. We just insert the strip of width
one to decrease the slope of this green edge, and the same for the edge on the
right.
So a shift step would not be [indiscernible] because [indiscernible] there is
an area to the left, an area to the right and you shift them to the left and to
the right. But here, these two areas meet behind the cylinder. So this is why
it was not convenient to formulate the shift step classically, but with dual
tree, everything is fine.
Okay. So now, as in the planar K, we insert the vertex as a straight hat.
Okay. So just an example, so we first draw the base is just the outer circle.
We draw it just as a line so it's periodic representation. We are careful that
the vertex must be evenly spaced with just a technical condition so that when
you insert the new vertex, it will be on a grid point. Okay. So now, you
insert an execution so you can check that at each step. There is -- it's a
periodic planar representation. And okay. Sorry. And it's like the FPP
algorithm, but it's periodic in X so this identifies with it. Okay. So now
the grid size, so it can be checked so the vertical spine at each edge is at
most the weight so it is at most the essentially the N times the graph distance
between the two boundaries.
And in the second step, we first decompose the [indiscernible] it to the outer
circles and if we take care of getting enough initial spacing, then we draw
this, the one [indiscernible] and if we are given initial spacing long enough,
then we will [indiscernible] to plug the [indiscernible] component using the
FPP algorithm for plane triangulations and we get a join.
So it works for any triangulation in the cylinder.
27
So finally, I just explained briefly -- okay, sorry. For the torus. So an
easy way to go from torus to cylinder would be to get around one cycle. But
the problem is that you duplicate vertices, so it's not very convenient to get
a drawing of the torus from the joints of the cylinder so we use the concept of
tambourine which means two circles directly parted. Two non-contractible
circles that are directly parted. In this way, when we did it, which is inside
this tambourine, we don't duplicate vertices and here's a strategy so you, with
the tambourine, you did it. So you start researching on the torus. When you
did it, which is in this tambourine, which you compute, you get a triangulation
on the cylinder. You draw it with our algorithm and if you give enough
vertical space, you can reinsert the edges of the tambourine. So in that
space, the [indiscernible] of slope greater than one in absolute value and then
it's fine. You don't have any crossing. So this is a drawing of this
triangulation in the torus. So I don't have all the details, but you don't
increase much the height and you can make sure that essentially, you see a
shortest non-contractible cycle going from one boundary to the other and so it
means that the height is bounded by N times the shortest non-contractible
cycle. Since it's a square root N, the height of our drawing is N to the
[indiscernible]. So we lose a factor of square ten compared to the plane. So
here are just extensions. So I probably don't have time.
But just to say that we can extend it to three connected maps and get convex
joints as in the planar case, and we would like to make our strategy work for
higher [indiscernible] but it would probably require it to work with
[indiscernible] drawing and [indiscernible] geometry.
Okay.
So that's it.
>>:
Thank you for the nice pictures here.
>>:
This is a straight line drawing on the flat torus, right?
>> Eric Fusy:
>>:
Questions?
Peter.
Yes, yes.
Is it possible to make that into a [indiscernible].
>> Eric Fusy: I wanted to, but I don't know if there is a way to -- well, you
can use a mapping from the [indiscernible] --
28
>>: I'm just wondering whether the straight lines turn into the
[indiscernible].
>> Eric Fusy: I wanted to think about it, but unfortunately, it went out of my
mind. But I'm not sure if there is a way to. If you make a transformation,
probably doesn't maintain the [indiscernible] so you want to be sure that if
you deform it into [indiscernible], you wouldn't create a question. I am not
expert on that.
>>: I think you have to preserve the local order. You don't have to pick the
[indiscernible] as the shortest, correct? But you have to be careful that you
go left to right. Maybe that you have to wrap around. As the straight line on
the cylinder.
>>:
All right.
Thank you again.
>>: For closing words, I would like to stress that this conference is the
result of very big cooperative effort, and this is why [indiscernible] and I
have to thank a lot of people. And first of all, I would like to thank again
Lev Nachmansen. And Tim, Tim Dwyer. And Natalie [indiscernible] and
[indiscernible]. She couldn't be here now who made the great job and managed
to perfectly organize the event, keeping prices low in a country where usually,
prices are more expensive than in other countries. So thank you again for
perfect management.
And we are also in
room and they made
reviews, as Walter
external viewers.
amount of work.
debt with the committee members. I see a lot of them in the
a terrific job selecting papers and posters, and we had 300
said in the business meeting, and one third of them were by
And you can rest assured that this selection was a huge
So above all, last but not least, I would like to thank all people who
submitted a paper to Graph Drawing 2012, paper or poster. We all know how many
hours of hard work and of our best time it cost to produce a good paper. And
we had over 100 submissions of papers and posters, and this gives very concrete
perception that this event is the result of the cooperative effort. So this is
a conference that rests on the shoulders of our research community, which is
rich of ideas, [indiscernible] of new things and open to new people. So thank
you for attending, and we are now passing the talk to the organizer of next
year [indiscernible] and we are sure that they will do a wonderful job next
29
year. So we look forward to seeing you next year in Bordeaux.
again.
So thank you