13,050 research outputs found
Peacock Bundles: Bundle Coloring for Graphs with Globality-Locality Trade-off
Bundling of graph edges (node-to-node connections) is a common technique to
enhance visibility of overall trends in the edge structure of a large graph
layout, and a large variety of bundling algorithms have been proposed. However,
with strong bundling, it becomes hard to identify origins and destinations of
individual edges. We propose a solution: we optimize edge coloring to
differentiate bundled edges. We quantify strength of bundling in a flexible
pairwise fashion between edges, and among bundled edges, we quantify how
dissimilar their colors should be by dissimilarity of their origins and
destinations. We solve the resulting nonlinear optimization, which is also
interpretable as a novel dimensionality reduction task. In large graphs the
necessary compromise is whether to differentiate colors sharply between locally
occurring strongly bundled edges ("local bundles"), or also between the weakly
bundled edges occurring globally over the graph ("global bundles"); we allow a
user-set global-local tradeoff. We call the technique "peacock bundles".
Experiments show the coloring clearly enhances comprehensibility of graph
layouts with edge bundling.Comment: Appears in the Proceedings of the 24th International Symposium on
Graph Drawing and Network Visualization (GD 2016
Breaking Instance-Independent Symmetries In Exact Graph Coloring
Code optimization and high level synthesis can be posed as constraint
satisfaction and optimization problems, such as graph coloring used in register
allocation. Graph coloring is also used to model more traditional CSPs relevant
to AI, such as planning, time-tabling and scheduling. Provably optimal
solutions may be desirable for commercial and defense applications.
Additionally, for applications such as register allocation and code
optimization, naturally-occurring instances of graph coloring are often small
and can be solved optimally. A recent wave of improvements in algorithms for
Boolean satisfiability (SAT) and 0-1 Integer Linear Programming (ILP) suggests
generic problem-reduction methods, rather than problem-specific heuristics,
because (1) heuristics may be upset by new constraints, (2) heuristics tend to
ignore structure, and (3) many relevant problems are provably inapproximable.
Problem reductions often lead to highly symmetric SAT instances, and
symmetries are known to slow down SAT solvers. In this work, we compare several
avenues for symmetry breaking, in particular when certain kinds of symmetry are
present in all generated instances. Our focus on reducing CSPs to SAT allows us
to leverage recent dramatic improvement in SAT solvers and automatically
benefit from future progress. We can use a variety of black-box SAT solvers
without modifying their source code because our symmetry-breaking techniques
are static, i.e., we detect symmetries and add symmetry breaking predicates
(SBPs) during pre-processing.
An important result of our work is that among the types of
instance-independent SBPs we studied and their combinations, the simplest and
least complete constructions are the most effective. Our experiments also
clearly indicate that instance-independent symmetries should mostly be
processed together with instance-specific symmetries rather than at the
specification level, contrary to what has been suggested in the literature
The Edge Group Coloring Problem with Applications to Multicast Switching
This paper introduces a natural generalization of the classical edge coloring
problem in graphs that provides a useful abstraction for two well-known
problems in multicast switching. We show that the problem is NP-hard and
evaluate the performance of several approximation algorithms, both analytically
and experimentally. We find that for random -colorable graphs, the number
of colors used by the best algorithms falls within a small constant factor of
, where the constant factor is mainly a function of the ratio of the
number of outputs to inputs. When this ratio is less than 10, the best
algorithms produces solutions that use fewer than colors. In addition,
one of the algorithms studied finds high quality approximate solutions for any
graph with high probability, where the probability of a low quality solution is
a function only of the random choices made by the algorithm
Improving bounds on large instances of graph coloring
This thesis explores new methods, using both vertex cover and exact graph coloring algorithms in addition to our implementation of the state of the art, to develop a hybrid algorithm that on most instances is able to tighten the bounds or determine the optimal number of colors outright
On the Complexity of Distributed Splitting Problems
One of the fundamental open problems in the area of distributed graph
algorithms is the question of whether randomization is needed for efficient
symmetry breaking. While there are fast, -time randomized
distributed algorithms for all of the classic symmetry breaking problems, for
many of them, the best deterministic algorithms are almost exponentially
slower. The following basic local splitting problem, which is known as the
\emph{weak splitting} problem takes a central role in this context: Each node
of a graph has to be colored red or blue such that each node of
sufficiently large degree has at least one node of each color among its
neighbors. Ghaffari, Kuhn, and Maus [STOC '17] showed that this seemingly
simple problem is complete w.r.t. the above fundamental open question in the
following sense: If there is an efficient -time determinstic
distributed algorithm for weak splitting, then there is such an algorithm for
all locally checkable graph problems for which an efficient randomized
algorithm exists. In this paper, we investigate the distributed complexity of
weak splitting and some closely related problems. E.g., we obtain efficient
algorithms for special cases of weak splitting, where the graph is nearly
regular. In particular, we show that if and are the minimum
and maximum degrees of and if , weak splitting can
be solved deterministically in time
. Further, if and , there is a
randomized algorithm with time complexity
Bin Packing and Related Problems: General Arc-flow Formulation with Graph Compression
We present an exact method, based on an arc-flow formulation with side
constraints, for solving bin packing and cutting stock problems --- including
multi-constraint variants --- by simply representing all the patterns in a very
compact graph. Our method includes a graph compression algorithm that usually
reduces the size of the underlying graph substantially without weakening the
model. As opposed to our method, which provides strong models, conventional
models are usually highly symmetric and provide very weak lower bounds.
Our formulation is equivalent to Gilmore and Gomory's, thus providing a very
strong linear relaxation. However, instead of using column-generation in an
iterative process, the method constructs a graph, where paths from the source
to the target node represent every valid packing pattern.
The same method, without any problem-specific parameterization, was used to
solve a large variety of instances from several different cutting and packing
problems. In this paper, we deal with vector packing, graph coloring, bin
packing, cutting stock, cardinality constrained bin packing, cutting stock with
cutting knife limitation, cutting stock with binary patterns, bin packing with
conflicts, and cutting stock with binary patterns and forbidden pairs. We
report computational results obtained with many benchmark test data sets, all
of them showing a large advantage of this formulation with respect to the
traditional ones
A Fast and Scalable Graph Coloring Algorithm for Multi-core and Many-core Architectures
Irregular computations on unstructured data are an important class of
problems for parallel programming. Graph coloring is often an important
preprocessing step, e.g. as a way to perform dependency analysis for safe
parallel execution. The total run time of a coloring algorithm adds to the
overall parallel overhead of the application whereas the number of colors used
determines the amount of exposed parallelism. A fast and scalable coloring
algorithm using as few colors as possible is vital for the overall parallel
performance and scalability of many irregular applications that depend upon
runtime dependency analysis.
Catalyurek et al. have proposed a graph coloring algorithm which relies on
speculative, local assignment of colors. In this paper we present an improved
version which runs even more optimistically with less thread synchronization
and reduced number of conflicts compared to Catalyurek et al.'s algorithm. We
show that the new technique scales better on multi-core and many-core systems
and performs up to 1.5x faster than its predecessor on graphs with high-degree
vertices, while keeping the number of colors at the same near-optimal levels.Comment: To appear in the proceedings of Euro Par 201
- …