8 research outputs found
Dynamic Graph Stream Algorithms in Space
In this paper we study graph problems in dynamic streaming model, where the
input is defined by a sequence of edge insertions and deletions. As many
natural problems require space, where is the number of
vertices, existing works mainly focused on designing space
algorithms. Although sublinear in the number of edges for dense graphs, it
could still be too large for many applications (e.g. is huge or the graph
is sparse). In this work, we give single-pass algorithms beating this space
barrier for two classes of problems.
We present space algorithms for estimating the number of connected
components with additive error and
-approximating the weight of minimum spanning tree, for any
small constant . The latter improves previous
space algorithm given by Ahn et al. (SODA 2012) for connected graphs with
bounded edge weights.
We initiate the study of approximate graph property testing in the dynamic
streaming model, where we want to distinguish graphs satisfying the property
from graphs that are -far from having the property. We consider
the problem of testing -edge connectivity, -vertex connectivity,
cycle-freeness and bipartiteness (of planar graphs), for which, we provide
algorithms using roughly space, which is
for any constant .
To complement our algorithms, we present space
lower bounds for these problems, which show that such a dependence on
is necessary.Comment: ICALP 201
Tight Regret Bounds for Single-pass Streaming Multi-armed Bandits
Regret minimization in streaming multi-armed bandits (MABs) has been studied
extensively in recent years. In the single-pass setting with arms and
trials, a regret lower bound of has been proved for any
algorithm with memory (Maiti et al. [NeurIPS'21]; Agarwal at al.
[COLT'22]). On the other hand, however, the previous best regret upper bound is
still , which is achieved by the streaming
implementation of the simple uniform exploration. The
gap leaves the open question of the tight regret bound in the single-pass MABs
with sublinear arm memory.
In this paper, we answer this open problem and complete the picture of regret
minimization in single-pass streaming MABs. We first improve the regret lower
bound to for algorithms with memory, which
matches the uniform exploration regret up to a logarithm factor in . We then
show that the factor is not necessary, and we can achieve
regret by finding an -best arm and committing
to it in the rest of the trials. For regret minimization with high constant
probability, we can apply the single-memory -best arm algorithms
in Jin et al. [ICML'21] to obtain the optimal bound. Furthermore, for the
expected regret minimization, we design an algorithm with a single-arm memory
that achieves regret, and an algorithm with
-memory with the optimal regret following
the -best arm algorithm in Assadi and Wang [STOC'20].
We further tested the empirical performances of our algorithms. The
simulation results show that the proposed algorithms consistently outperform
the benchmark uniform exploration algorithm by a large margin, and on occasion,
reduce the regret by up to 70%.Comment: ICML 202
Near-Quadratic Lower Bounds for Two-Pass Graph Streaming Algorithms
We prove that any two-pass graph streaming algorithm for the -
reachability problem in -vertex directed graphs requires near-quadratic
space of bits. As a corollary, we also obtain near-quadratic space
lower bounds for several other fundamental problems including maximum bipartite
matching and (approximate) shortest path in undirected graphs.
Our results collectively imply that a wide range of graph problems admit
essentially no non-trivial streaming algorithm even when two passes over the
input is allowed. Prior to our work, such impossibility results were only known
for single-pass streaming algorithms, and the best two-pass lower bounds only
ruled out space algorithms, leaving open a large gap between
(trivial) upper bounds and lower bounds
Exploration with Limited Memory: Streaming Algorithms for Coin Tossing, Noisy Comparisons, and Multi-Armed Bandits
Consider the following abstract coin tossing problem: Given a set of
coins with unknown biases, find the most biased coin using a minimal number of
coin tosses. This is a common abstraction of various exploration problems in
theoretical computer science and machine learning and has been studied
extensively over the years. In particular, algorithms with optimal sample
complexity (number of coin tosses) have been known for this problem for quite
some time.
Motivated by applications to processing massive datasets, we study the space
complexity of solving this problem with optimal number of coin tosses in the
streaming model. In this model, the coins are arriving one by one and the
algorithm is only allowed to store a limited number of coins at any point --
any coin not present in the memory is lost and can no longer be tossed or
compared to arriving coins. Prior algorithms for the coin tossing problem with
optimal sample complexity are based on iterative elimination of coins which
inherently require storing all the coins, leading to memory-inefficient
streaming algorithms.
We remedy this state-of-affairs by presenting a series of improved streaming
algorithms for this problem: we start with a simple algorithm which require
storing only coins and then iteratively refine it further and
further, leading to algorithms with memory,
memory, and finally a one that only stores a single extra coin in memory -- the
same exact space needed to just store the best coin throughout the stream.
Furthermore, we extend our algorithms to the problem of finding the most
biased coins as well as other exploration problems such as finding top-
elements using noisy comparisons or finding an -best arm in
stochastic multi-armed bandits, and obtain efficient streaming algorithms for
these problems
On Flows, Paths, Roots, and Zeros
This thesis has two parts; in the first of which we give new results for various network flow problems. (1) We present a novel dual ascent algorithm for min-cost flow and show that an implementation of it is very efficient on certain instance classes. (2) We approach the problem of numerical stability of interior point network flow algorithms by giving a path following method that works with integer arithmetic solely and is thus guaranteed to be free of any nu-merical instabilities. (3) We present a gradient descent approach for the undirected transship-ment problem and its special case, the single source shortest path problem (SSSP). For distrib-uted computation models this yields the first SSSP-algorithm with near-optimal number of communication rounds. The second part deals with fundamental topics from algebraic computation. (1) We give an algorithm for computing the complex roots of a complex polynomial. While achieving a com-parable bit complexity as previous best results, our algorithm is simple and promising to be of practical impact. It uses a test for counting the roots of a polynomial in a region that is based on Pellet's theorem. (2) We extend this test to polynomial systems, i.e., we develop an algorithm that can certify the existence of a k-fold zero of a zero-dimensional polynomial system within a given region. For bivariate systems, we show experimentally that this approach yields signifi-cant improvements when used as inclusion predicate in an elimination method.Im ersten Teil dieser Dissertation präsentieren wir neue Resultate für verschiedene Netzwerkflussprobleme. (1)Wir geben eine neue Duale-Aufstiegsmethode für das Min-Cost-Flow- Problem an und zeigen, dass eine Implementierung dieser Methode sehr effizient auf gewissen Instanzklassen ist. (2)Wir behandeln numerische Stabilität von Innere-Punkte-Methoden fürNetwerkflüsse, indem wir eine solche Methode angeben die mit ganzzahliger Arithmetik arbeitet und daher garantiert frei von numerischen Instabilitäten ist. (3) Wir präsentieren ein Gradienten-Abstiegsverfahren für das ungerichtete Transshipment-Problem, und seinen Spezialfall, das Single-Source-Shortest-Problem (SSSP), die für SSSP in verteilten Rechenmodellen die erste mit nahe-optimaler Anzahl von Kommunikationsrunden ist. Der zweite Teil handelt von fundamentalen Problemen der Computeralgebra. (1) Wir geben einen Algorithmus zum Berechnen der komplexen Nullstellen eines komplexen Polynoms an, der eine vergleichbare Bitkomplexität zu vorherigen besten Resultaten hat, aber vergleichsweise einfach und daher vielversprechend für die Praxis ist. (2)Wir erweitern den darin verwendeten Pellet-Test zum Zählen der Nullstellen eines Polynoms auf Polynomsysteme, sodass wir die Existenz einer k-fachen Nullstelle eines Systems in einer gegebenen Region zertifizieren können. Für bivariate Systeme zeigen wir experimentell, dass eine Integration dieses Ansatzes in eine Eliminationsmethode zu einer signifikanten Verbesserung führt