2016 Proceedings of the SIAM Workshop on Combinatorial Scientific Computing (CSC)

Frontmatter includes preface, acknowledgments, List of Invited Talks, List of Contributed Talks, List of Posters, Table of Contents

Matrices associated with graphs, such as the Laplacian, lead to numerous interesting graph problems expressed as linear systems. One field where Laplacian linear systems play a role is network analysis, e. g. for certain centrality measures that indicate if a node (or an edge) is important in the network. One such centrality measure is current-flow closeness.

To allow network analysis workflows to profit from a fast Laplacian solver, we provide an implementation of the LAMG multigrid solver in the NetworKit package, facilitating the computation of current-flow closeness values or related quantities. Our main contribution consists of two algorithms that accelerate the current-flow computation for one node or a reasonably small node subset significantly. One algorithm is an unbiased estimator using sampling, the other one is based on the Johnson-Lindenstrauss transform. Our inexact algorithms lead to very accurate results in practice. Thanks to them one is now able to compute an estimation of current-flow closeness of one node on networks with tens of millions of nodes and edges within seconds or a few minutes. From a network analytical point of view, our experiments indicate that current-flow closeness can discriminate among different nodes significantly better than traditional shortest-path closeness and is also considerably more resistant to noise – we thus show that two known drawbacks of shortest-path closeness are alleviated by the current-flow variant.

A triangular solver is an important computational kernel in many applications. On-node parallelism is increasingly important. Multiple approaches underlying multithreaded triangular solvers exist. This article introduces a hybridization approach to combine two classes of parallel triangular solvers, level scheduling and blocking, to efficiently solve triangular systems having a much wider range of sparsity patterns than either algorithm class can efficiently address on its own. The open source software HTS implements a hybrid multithreaded triangular solver and is available in Trilinos.

Numerical techniques involving linearizations of nonlinear functions require the repeated solution of systems of linear equations whose coefficient matrix is the Jacobian of that nonlinear function. If the Jacobian is large and sparse, iterative methods offer the advantage that they involve the Jacobian solely in the form of matrix-vector products. Techniques of automatic differentiation are capable of evaluating these Jacobian-vector products efficiently and accurately in a matrix-free fashion. So, the numerical technique does not need to store the Jacobian explicitly. When the solution of the linear system is preconditioned, however, there is currently a considerable gap between automatic differentiation and preconditioning because the latter typically requires to explicitly store the Jacobian in a sparse data format. In an attempt to bridge this gap, we introduce an approach based on block diagonal preconditioning that brings together known computational building blocks in a novel way. The crucial methodological ingredient to that approach is the formulation and solution of a partial coloring problem in which colors are assigned to only a subset of the vertices of the underlying graph. Numerical experiments are reported that demonstrate the feasibility of this approach.

We study the performance of linear solvers for graph Laplacians based on the combinatorial cycle adjustment methodology proposed by [Kelner-Orecchia-Sidford-Zhu STOC-13]. The approach finds a dual flow solution to this linear system through a sequence of flow adjustments along cycles. We study both data structure oriented and recursive methods for handling these adjustments.

The primary difficulty faced by this approach, updating and querying long cycles, motivated us to study an important special case: instances where all cycles are formed by fundamental cycles on a length n path. Our methods demonstrate significant speedups over previous implementations, and are competitive with standard numerical routines.

We study a graph partitioning problem motivated by the simulation of the physical movement of multi-body systems on an atomistic level, where the forces are calculated from a quantum mechanical description of the electrons. Several advanced algorithms have been published in the literature for such simulations that are based on evaluations of matrix polynomials. We aim at efficiently parallelizing these computations by using a special type of graph partitioning. For this, we represent the zero-nonzero structure of a thresholded matrix as a graph and partition that graph into several components. The matrix polynomial is then evaluated for each separate submatrix corresponding to the subgraphs and the evaluated submatrix polynomials are used to assemble the final result for the full matrix polynomial. The paper provides a rigorous definition as well as a mathematical justification of this partitioning problem. We use several algorithms to compute graph partitions and experimentally evaluate their performance with respect to the quality of the partition obtained with each method and the time needed to produce it.

We describe a 3/2-approximation algorithm, LSE, for computing a b-Edge Cover of minimum weight in a graph with weights on the edges. The b-Edge Cover problem is a generalization of the better-known Edge Cover problem in graphs, where the objective is to choose a subset C of edges in the graph such that at least a specified number b(v) of edges in C are incident on each vertex v. In the weighted b-Edge Cover problem, we minimize the sum of the weights of the edges in C. We prove that the LSE algorithm computes the same b-Edge Cover as the one obtained by the Greedy algorithm for the problem. However, the Greedy algorithm requires edges to be sorted by their effective weights, and these weights need to be updated after each iteration. These requirements make the Greedy algorithm sequential and impractical for massive graphs. The LSE algorithm avoids the sorting step, and is amenable for parallelization. We implement the algorithm on a serial machine and compare its performance against a collection of approximation algorithms for the b-Edge Cover problem. Our results show that the LSE algorithm is 3× to 5× faster than the Greedy algorithm on a serial processor. The approximate edge covers obtained by the LSE algorithm have weights greater by at most 17% of the optimal weight for problems where we could compute the latter. We also investigate the relationship between the b-Edge Cover and the b-Matching problems, show that the latter has a faster implementation since edge weights are static in this algorithm, and obtain a heuristic solution for the former from the latter.

We describe a new approach based on tropical optimization techniques to solve the problem of rating alternatives from pairwise comparison data. The problem is formulated to approximate, in the log-Chebyshev sense, pairwise comparison matrices by reciprocal matrices of unit rank, and then represented in general terms of tropical mathematics as a tropical optimization problem. The optimization problem takes a common, unified form for both multiplicative and additive comparison scales. We apply recent results in tropical optimization to offer new complete solutions to the rating problems under various assumptions about the pairwise comparison matrices. The solutions are given in a compact vector form, which extends known solutions and involves modest computational efforts. The results obtained are illustrated with numerical examples. Specifically, we show by example that the partial solution known before may miss better results provided by the new complete solution. An example to demonstrate a tropical analogue of the analytical hierarchy process decision scheme is also given.

Platooning vehicles—connected and automated vehicles traveling with small intervehicle distances—use less fuel because of reduced aerodynamic drag. Given a network defined by vertex and edge sets and a set of vehicles with origin/destination nodes/times, we model and solve the combinatorial optimization problem of coordinated routing of vehicles in a manner that routes them to their destination on time while using the least amount of fuel. Common approaches decompose the platoon coordination and vehicle routing into separate problems. Our model addresses both problems simultaneously to obtain the best solution. We use modern modeling techniques and constraints implied from analyzing the platoon routing problem to address larger numbers of vehicles and larger networks than previously considered. While the numerical method used is unable to certify optimality for candidate solutions to all networks and parameters considered, we obtain excellent solutions in approximately one minute for much larger networks and vehicle sets than previously considered in the literature.

We propose a mixed integer programming (MIP) formulation for the call tree reversal (CTR) problem. CTR is a special case of checkpointing, which is a widely used technique to reverse the data flow of a computer program with only a limited amount of available persistent memory. Commercial solvers are used for MIP and results are compared to known heuristics. We show applicability, efficiency, and flexibility of MIP on a realistic case study based on PETSc.

Research on stable marriage problems has a long and mathematically rigorous history, while that of exploiting greedy matchings in combinatorial scientific computing is a younger and less developed research field. We consider the relationships between these two areas. In particular we show that several problems related to computing greedy matchings can be formulated as stable marriage problems and as a consequence several recently proposed algorithms for computing greedy matchings are in fact special cases of well known algorithms for the stable marriage problem.

However, in terms of implementations and practical scalable solutions on modern hardware, work on computing greedy matchings has made considerable progress. We show that due to this strong relationship many of these results are also applicable for solving stable marriage problems. This is further demonstrated by designing and testing efficient multicore as well as GPU algorithms for the stable marriage problem.

We prove the equivalence of two different Hessian evaluation algorithms in AD. The first is the Edge Pushing algorithm of Gower and Mello, which may be viewed as a second order Reverse mode algorithm for computing the Hessian. In earlier work, we have derived the Edge Pushing algorithm by exploiting a Reverse mode invariant based on the concept of live variables in compiler theory. The second algorithm is based on eliminating vertices in a computational graph of the gradient, in which intermediate variables are successively eliminated from the graph, and the weights of the edges are updated suitably. We prove that if the vertices are eliminated in a reverse topological order while preserving symmetry in the computational graph of the gradient, then the Vertex Elimination algorithm and the Edge Pushing algorithm perform identical computations. In this sense, the two algorithms are equivalent. This insight that unifies two seemingly disparate approaches to Hessian computations could lead to improved algorithms and implementations for computing Hessians.