9,359 research outputs found
The Entropy of Backwards Analysis
Backwards analysis, first popularized by Seidel, is often the simplest most
elegant way of analyzing a randomized algorithm. It applies to incremental
algorithms where elements are added incrementally, following some random
permutation, e.g., incremental Delauney triangulation of a pointset, where
points are added one by one, and where we always maintain the Delauney
triangulation of the points added thus far. For backwards analysis, we think of
the permutation as generated backwards, implying that the th point in the
permutation is picked uniformly at random from the points not picked yet in
the backwards direction. Backwards analysis has also been applied elegantly by
Chan to the randomized linear time minimum spanning tree algorithm of Karger,
Klein, and Tarjan.
The question considered in this paper is how much randomness we need in order
to trust the expected bounds obtained using backwards analysis, exactly and
approximately. For the exact case, it turns out that a random permutation works
if and only if it is minwise, that is, for any given subset, each element has
the same chance of being first. Minwise permutations are known to have
entropy, and this is then also what we need for exact backwards
analysis.
However, when it comes to approximation, the two concepts diverge
dramatically. To get backwards analysis to hold within a factor , the
random permutation needs entropy . This contrasts with
minwise permutations, where it is known that a approximation
only needs entropy. Our negative result for
backwards analysis essentially shows that it is as abstract as any analysis
based on full randomness
Constructing Light Spanners Deterministically in Near-Linear Time
Graph spanners are well-studied and widely used both in theory and practice. In a recent breakthrough, Chechik and Wulff-Nilsen [Shiri Chechik and Christian Wulff-Nilsen, 2018] improved the state-of-the-art for light spanners by constructing a (2k-1)(1+epsilon)-spanner with O(n^(1+1/k)) edges and O_epsilon(n^(1/k)) lightness. Soon after, Filtser and Solomon [Arnold Filtser and Shay Solomon, 2016] showed that the classic greedy spanner construction achieves the same bounds. The major drawback of the greedy spanner is its running time of O(mn^(1+1/k)) (which is faster than [Shiri Chechik and Christian Wulff-Nilsen, 2018]). This makes the construction impractical even for graphs of moderate size. Much faster spanner constructions do exist but they only achieve lightness Omega_epsilon(kn^(1/k)), even when randomization is used.
The contribution of this paper is deterministic spanner constructions that are fast, and achieve similar bounds as the state-of-the-art slower constructions. Our first result is an O_epsilon(n^(2+1/k+epsilon\u27)) time spanner construction which achieves the state-of-the-art bounds. Our second result is an O_epsilon(m + n log n) time construction of a spanner with (2k-1)(1+epsilon) stretch, O(log k * n^(1+1/k) edges and O_epsilon(log k * n^(1/k)) lightness. This is an exponential improvement in the dependence on k compared to the previous result with such running time. Finally, for the important special case where k=log n, for every constant epsilon>0, we provide an O(m+n^(1+epsilon)) time construction that produces an O(log n)-spanner with O(n) edges and O(1) lightness which is asymptotically optimal. This is the first known sub-quadratic construction of such a spanner for any k = omega(1).
To achieve our constructions, we show a novel deterministic incremental approximate distance oracle. Our new oracle is crucial in our construction, as known randomized dynamic oracles require the assumption of a non-adaptive adversary. This is a strong assumption, which has seen recent attention in prolific venues. Our new oracle allows the order of the edge insertions to not be fixed in advance, which is critical as our spanner algorithm chooses which edges to insert based on the answers to distance queries. We believe our new oracle is of independent interest
- …