9 research outputs found
Quantum and approximation algorithms for maximum witnesses of Boolean matrix products
The problem of finding maximum (or minimum) witnesses of the Boolean product
of two Boolean matrices (MW for short) has a number of important applications,
in particular the all-pairs lowest common ancestor (LCA) problem in directed
acyclic graphs (dags). The best known upper time-bound on the MW problem for
n\times n Boolean matrices of the form O(n^{2.575}) has not been substantially
improved since 2006. In order to obtain faster algorithms for this problem, we
study quantum algorithms for MW and approximation algorithms for MW (in the
standard computational model). Some of our quantum algorithms are input or
output sensitive. Our fastest quantum algorithm for the MW problem, and
consequently for the related problems, runs in time
\tilde{O}(n^{2+\lambda/2})=\tilde{O}(n^{2.434}), where \lambda satisfies the
equation \omega(1, \lambda, 1) = 1 + 1.5 \, \lambda and \omega(1, \lambda, 1)
is the exponent of the multiplication of an n \times n^{\lambda}$ matrix by an
n^{\lambda} \times n matrix. Next, we consider a relaxed version of the MW
problem (in the standard model) asking for reporting a witness of bounded rank
(the maximum witness has rank 1) for each non-zero entry of the matrix product.
First, by adapting the fastest known algorithm for maximum witnesses, we obtain
an algorithm for the relaxed problem that reports for each non-zero entry of
the product matrix a witness of rank at most \ell in time
\tilde{O}((n/\ell)n^{\omega(1,\log_n \ell,1)}). Then, by reducing the relaxed
problem to the so called k-witness problem, we provide an algorithm that
reports for each non-zero entry C[i,j] of the product matrix C a witness of
rank O(\lceil W_C(i,j)/k\rceil ), where W_C(i,j) is the number of witnesses for
C[i,j], with high probability. The algorithm runs in
\tilde{O}(n^{\omega}k^{0.4653} +n^2k) time, where \omega=\omega(1,1,1).Comment: 14 pages, 3 figure
Properties of Small Ordered Graphs Whose Vertices are Weighted by Their Degree
Graphs can effectively model biomolecules, computer systems, and other applications. A weighted graph is a graph in which values or labels are assigned to the edges of the graph. However, in this thesis, we assign values to the vertices of the graph rather than the edges and we modify several standard graphical measures to incorporate these vertex weights. In particular, we designate the degree of each vertex as its weight. Previous research has not investigated weighting vertices by degree. We find the vertex weighted domination number in connected graphs, beginning with trees, and we define how weighted vertices can affect eccentricity, independence number, and connectivity
Quantum Algorithms for Matrix Products over Semirings
In this paper we construct quantum algorithms for matrix products over
several algebraic structures called semirings, including the (max,min)-matrix
product, the distance matrix product and the Boolean matrix product. In
particular, we obtain the following results.
We construct a quantum algorithm computing the product of two n x n matrices
over the (max,min) semiring with time complexity O(n^{2.473}). In comparison,
the best known classical algorithm for the same problem, by Duan and Pettie,
has complexity O(n^{2.687}). As an application, we obtain a O(n^{2.473})-time
quantum algorithm for computing the all-pairs bottleneck paths of a graph with
n vertices, while classically the best upper bound for this task is
O(n^{2.687}), again by Duan and Pettie.
We construct a quantum algorithm computing the L most significant bits of
each entry of the distance product of two n x n matrices in time O(2^{0.64L}
n^{2.46}). In comparison, prior to the present work, the best known classical
algorithm for the same problem, by Vassilevska and Williams and Yuster, had
complexity O(2^{L}n^{2.69}). Our techniques lead to further improvements for
classical algorithms as well, reducing the classical complexity to
O(2^{0.96L}n^{2.69}), which gives a sublinear dependency on 2^L.
The above two algorithms are the first quantum algorithms that perform better
than the -time straightforward quantum algorithm based on
quantum search for matrix multiplication over these semirings. We also consider
the Boolean semiring, and construct a quantum algorithm computing the product
of two n x n Boolean matrices that outperforms the best known classical
algorithms for sparse matrices. For instance, if the input matrices have
O(n^{1.686...}) non-zero entries, then our algorithm has time complexity
O(n^{2.277}), while the best classical algorithm has complexity O(n^{2.373}).Comment: 19 page
Fine-Grained Complexity and Algorithms for the Schulze Voting Method
We study computational aspects of a well-known single-winner voting rule
called the Schulze method [Schulze, 2003] which is used broadly in practice. In
this method the voters give (weak) ordinal preference ballots which are used to
define the weighted majority graph (WMG) of direct comparisons between pairs of
candidates. The choice of the winner comes from indirect comparisons in the
graph, and more specifically from considering directed paths instead of direct
comparisons between candidates.
When the input is the WMG, to our knowledge, the fastest algorithm for
computing all winners in the Schulze method uses a folklore reduction to the
All-Pairs Bottleneck Paths problem and runs in time, where is
the number of candidates. It is an interesting open question whether this can
be improved. Our first result is a combinatorial algorithm with a nearly
quadratic running time for computing all winners. This running time is
essentially optimal. If the input to the Schulze winners problem is not the WMG
but the preference profile, then constructing the WMG is a bottleneck that
increases the running time significantly; in the special case when there are
candidates and voters, the running time is , or
if there is a nearly-linear time algorithm for multiplying dense
square matrices. To address this bottleneck, we prove a formal equivalence
between the well-studied Dominance Product problem and the problem of computing
the WMG. We prove a similar connection between the so called Dominating Pairs
problem and the problem of finding a winner in the Schulze method.
Our paper is the first to bring fine-grained complexity into the field of
computational social choice. Using it we can identify voting protocols that are
unlikely to be practical for large numbers of candidates and/or voters, as
their complexity is likely, say at least cubic.Comment: 19 pages, 2 algorithms, 2 tables. A previous version of this work
appears in EC 2021. In this version we strengthen Theorem 6.2 which now holds
also for the problem of finding a Schulze winne
All-Pairs LCA in DAGs: Breaking through the barrier
Let be an -vertex directed acyclic graph (DAG). A lowest common
ancestor (LCA) of two vertices and is a common ancestor of and
such that no descendant of has the same property. In this paper, we
consider the problem of computing an LCA, if any, for all pairs of vertices in
a DAG. The fastest known algorithms for this problem exploit fast matrix
multiplication subroutines and have running times ranging from
[Bender et al.~SODA'01] down to [Kowaluk and Lingas~ICALP'05]
and [Czumaj et al.~TCS'07]. Somewhat surprisingly, all those
bounds would still be even if matrix multiplication could be
solved optimally (i.e., ). This appears to be an inherent barrier for
all the currently known approaches, which raises the natural question on
whether one could break through the barrier for this problem.
In this paper, we answer this question affirmatively: in particular, we
present an ( for ) algorithm
for finding an LCA for all pairs of vertices in a DAG, which represents the
first improvement on the running times for this problem in the last 13 years. A
key tool in our approach is a fast algorithm to partition the vertex set of the
transitive closure of into a collection of chains and
antichains, for a given parameter . As usual, a chain is a path while an
antichain is an independent set. We then find, for all pairs of vertices, a
\emph{candidate} LCA among the chain and antichain vertices, separately. The
first set is obtained via a reduction to min-max matrix multiplication. The
computation of the second set can be reduced to Boolean matrix multiplication
similarly to previous results on this problem. We finally combine the two
solutions together in a careful (non-obvious) manner
All-Pairs Bottleneck Paths in Vertex Weighted Graphs
Let G = (V, E, w) be a directed graph, where w: V â R is an arbitrary weight function defined on its vertices. The bottleneck weight, or the capacity, of a path is the smallest weight of a vertex on the path. For two vertices u, v the bottleneck weight, or the capacity, from u to v, denoted c(u, v), is the maximum bottleneck weight of a path from u to v. In the All-Pairs Bottleneck Paths (APBP) problem we have to find the bottleneck weights for all ordered pairs of vertices. Our main result is an O(n 2.575) time algorithm for the APBP problem. The exponent is derived from the exponent of fast matrix multiplication. Our algorithm is the first sub-cubic algorithm for this problem. Unlike the sub-cubic algorithm for the all-pairs shortest paths (APSP) problem, that only applies to bounded (or relatively small) integer edge or vertex weights, the algorithm presented for APBP problem works for arbitrary large vertex weights. The APBP problem has numerous applications, and several interesting problems that have recently attracted attention can be reduced to it, with no asymptotic loss in the running times of the known algorithms for these problems. Some examples are a result of Vassilevska and Williams [STOC 2006] on finding a triangle of maximum weight, a result of Bender et al. [SODA 2001] o
Combining Shortest Paths, Bottleneck Paths and Matrix Multiplication
We provide a formal mathematical definition of the Shortest Paths for All Flows (SP-AF) problem and provide many efficient algorithms. The SP-AF problem combines the well known Shortest Paths (SP) and Bottleneck Paths (BP) problems, and can be solved by utilising matrix multiplication. Thus in our research of the SP-AF problem, we also make a series of contributions to the underlying topics of the SP problem, the BP problem, and matrix multiplication.
For the topic of matrix multiplication we show that on an n-by-n two dimensional (2D) square mesh array, two n-by-n matrices can be multiplied in exactly 1.5n â 1 communication steps. This halves the number of communication steps required by the well known Cannonâs algorithm that runs
on the same sized mesh array.
We provide two contributions for the SP problem. Firstly, we enhance the breakthrough algorithm by Alon, Galil and Margalit (AGM), which was the first algorithm to achieve a deeply sub-cubic time bound for solving the All Pairs Shortest Paths (APSP) problem on dense directed graphs. Our enhancement allows the algorithm by AGM to remain sub-cubic for larger upper bounds on integer edge costs. Secondly, we show that for graphs with n vertices, the APSP problem can be solved in exactly 3n â 2 communication steps on an n-by-n 2D square mesh array. This improves on the previous result of 3.5n communication steps achieved by Takaoka and Umehara.
For the BP problem, we show that we can compute the bottleneck of the entire graph without solving the All Pairs Bottleneck Paths (APBP) problem, resulting in a much more efficient time bound.
Finally we define an algebraic structure called the distance/flow semi-ring to formally introduce the SP-AF problem, and we provide many algorithms for solving the Single Source SP-AF (SSSP-AF) problem and the All Pairs SP-AF (APSP-AF) problem. For the APSP-AF problem, algebraic algorithms are given that utilise faster matrix multiplication over a ring
Algorithms and Dynamic Data Structures for Basic Graph Optimization Problems.
Graph optimization plays an important role in a wide range of areas such as computer graphics, computational biology, networking applications and machine learning. Among numerous graph optimization problems, some basic problems, such as shortest paths, minimum spanning tree, and maximum matching, are the most fundamental ones. They have practical applications in various fields, and are also building blocks of many other algorithms. Improvements in algorithms for these problems can thus have a great impact both in practice and in theory.
In this thesis, we study a number of graph optimization problems. The results are mostly about approximation algorithms solving graph problems, or efficient dynamic data structures which can answer graph queries when a number of changes occur. Much of my work focuses on the dynamic subgraph model in which there is a fixed underlying graph and every vertex can be flipped "on" or "off". The queries are based on the subgraph induced by the "on" vertices. Our results make significant improvements to the previous algorithms of these problems.
The major results are listed below.
Approximate Matching. We give the first linear time algorithm for computing approximate maximum weighted matching for arbitrarily small approximation ratio.
d-failure Connectivity Oracle. For an undirected graph, we give the first space efficient data structure that can answer connectivity queries between any pair of vertices avoiding d other failed vertices in time polynomial in d and log n.
(Max, Min)-Matrix Multiplication. We give a faster algorithm for the (max, min)-matrix multiplication problem, which has a direct application to the all- pairs bottleneck paths (APBP) problem.
Dual-failure Distance Oracle. We construct the data structure for a given directed graph of nearly quadratic space which can efficiently answer distance and shortest path queries in the presence of two node or link failures.
Dynamic Subgraph Connectivity. We give the first subgraph connectivity structure with worst-case sublinear time bounds for both updates and queries.
Bounded-leg Shortest Path. We give an algorithm for preprocessing a directed graph in nearly cubic time in order to answer approximate bounded-leg distance and bounded-leg shortest path queries in merely sub-logarithmic time.Ph.D.Computer Science & EngineeringUniversity of Michigan, Horace H. Rackham School of Graduate Studieshttp://deepblue.lib.umich.edu/bitstream/2027.42/89641/1/duanran_1.pd