arXiv subjects

Michael Elkin

Publications and source records attributed to Michael Elkin.

49 records · Page 3Linked to original sources

arXiv2014

Can Quantum Communication Speed Up Distributed Computation?

The focus of this paper is on {\em quantum distributed} computation, where we investigate whether quantum communication can help in {\em speeding up} distributed network algorithms. Our main result is that for certain fundamental network problems such as minimum spanning tree, minimum cut, and shortest paths, quantum communication {\em does not} help in substantially speeding up distributed algorithms for these problems compared to the classical setting. In order to obtain this result, we extend the technique of Das Sarma et al. [SICOMP 2012] to obtain a uniform approach to prove non-trivial lower bounds for quantum distributed algorithms for several graph optimization (both exact and approximate versions) as well as verification problems, some of which are new even in the classical setting, e.g. tight randomized lower bounds for Hamiltonian cycle and spanning tree verification, answering an open problem of Das Sarma et al., and a lower bound in terms of the weight aspect ratio, matching the upper bounds of Elkin [STOC 2004]. Our approach introduces the {\em Server model} and {\em Quantum Simulation Theorem} which together provide a connection between distributed algorithms and communication complexity. The Server model is the standard two-party communication complexity model augmented with additional power; yet, most of the hardness in the two-party model is carried over to this new model. The Quantum Simulation Theorem carries this hardness further to quantum distributed computing. Our techniques, except the proof of the hardness in the Server model, require very little knowledge in quantum computing, and this can help overcoming a usual impediment in proving bounds on quantum distributed algorithms.

cs.DC↗

arXiv2014

Light Spanners

A $t$-spanner of a weighted undirected graph $G=(V,E)$, is a subgraph $H$ such that $d_H(u,v)\le t\cdot d_G(u,v)$ for all $u,v\in V$. The sparseness of the spanner can be measured by its size (the number of edges) and weight (the sum of all edge weights), both being important measures of the spanner's quality -- in this work we focus on the latter. Specifically, it is shown that for any parameters $k\ge 1$ and $ε>0$, any weighted graph $G$ on $n$ vertices admits a $(2k-1)\cdot(1+ε)$-stretch spanner of weight at most $w(MST(G))\cdot O_ε(kn^{1/k}/\log k)$, where $w(MST(G))$ is the weight of a minimum spanning tree of $G$. Our result is obtained via a novel analysis of the classic greedy algorithm, and improves previous work by a factor of $O(\log k)$.

cs.DS↗

arXiv2012

Optimal Euclidean spanners: really short, thin and lanky

In a seminal STOC'95 paper, titled "Euclidean spanners: short, thin and lanky", Arya et al. devised a construction of Euclidean $(1+\eps)$-spanners that achieves constant degree, diameter $O(\log n)$, and weight $O(\log^2 n) \cdot ω(MST)$, and has running time $O(n \cdot \log n)$. This construction applies to $n$-point constant-dimensional Euclidean spaces. Moreover, Arya et al. conjectured that the weight bound can be improved by a logarithmic factor, without increasing the degree and the diameter of the spanner, and within the same running time. This conjecture of Arya et al. became a central open problem in the area of Euclidean spanners. In this paper we resolve the long-standing conjecture of Arya et al. in the affirmative. Specifically, we present a construction of spanners with the same stretch, degree, diameter, and running time, as in Arya et al.'s result, but with optimal weight $O(\log n) \cdot ω(MST)$. Moreover, our result is more general in three ways. First, we demonstrate that the conjecture holds true not only in constant-dimensional Euclidean spaces, but also in doubling metrics. Second, we provide a general tradeoff between the three involved parameters, which is tight in the entire range. Third, we devise a transformation that decreases the lightness of spanners in general metrics, while keeping all their other parameters in check. Our main result is obtained as a corollary of this transformation.

cs.DS↗

arXiv2012

Fast Constructions of Light-Weight Spanners for General Graphs

To our knowledge, there are only two known algorithms for constructing sparse and light spanners for general graphs. One of them is the greedy algorithm of Alth$\ddot{o}$fer et al. \cite{ADDJS93}, analyzed by Chandra et al. in SoCG'92. The greedy algorithm consructs, for every \emph{weighted} undirected $n$-vertex $m$-edge graph $G = (V,E)$ and any integer $k \ge 1$, a $(2k-1)$-spanner with $O(n^{1 + 1/k})$ edges and weight $O(k \cdot n^{(1+\eps)/k}) \cdot ω(MST(G))$, for any $\eps > 0$. The drawback of the greedy algorithm is that it requires $O(m \cdot (n^{1 + 1/k} + n \cdot \log n))$ time. The other algorithm is due to Awerbuch et al. \cite{ABP91}. It constructs $O(k)$-spanners with $O(k \cdot n^{1 + 1/k} \cdot Λ)$ edges, weight $O(k^2 \cdot n^{1/k} \cdot Λ) \cdot ω(MST(G))$, within time $O(m \cdot k \cdot n^{1/k} \cdot Λ)$, where $Λ$ is the logarithm of the aspect ratio of the graph. The running time of both these algorithms is unsatisfactory. Moreover, the usually faster algorithm of \cite{ABP91} pays for the speedup by significantly increasing both the stretch, the sparsity, and the weight of the resulting spanner. In this paper we devise an efficient algorithm for constructing sparse and light spanners. Specifically, our algorithm constructs $((2k-1) \cdot (1+\eps))$-spanners with $O(k \cdot n^{1 + 1/k})$ edges and weight $O(k \cdot n^{1/k}) \cdot ω(MST(G))$, where $\eps > 0$ is an arbitrarily small constant. The running time of our algorithm is $O(k \cdot m + \min\{n \cdot \log n,m \cdot α(n)\})$. Moreover, by slightly increasing the running time we can reduce the other parameters. These results address an open problem from the ESA'04 paper by Roditty and Zwick \cite{RZ04}.

cs.DS↗

arXiv2012

Energy fluctuations shape free energy of nonspecific biomolecular interactions

Understanding design principles of biomolecular recognition is a key question of molecular biology. Yet the enormous complexity and diversity of biological molecules hamper the efforts to gain a predictive ability for the free energy of protein-protein, protein-DNA, and protein-RNA binding. Here, using a variant of the Derrida model, we predict that for a large class of biomolecular interactions, it is possible to accurately estimate the relative free energy of binding based on the fluctuation properties of their energy spectra, even if a finite number of the energy levels is known. We show that the free energy of the system possessing a wider binding energy spectrum is almost surely lower compared with the system possessing a narrower energy spectrum. Our predictions imply that low-affinity binding scores, usually wasted in protein-protein and protein-DNA docking algorithms, can be efficiently utilized to compute the free energy. Using the results of Rosetta docking simulations of protein-protein interactions from Andre et al., Proc. Natl. Acad. Sci. U.S.A. 105, 16148 (2008), we demonstrate the power of our predictions.

q-bio.BM↗

arXiv2011

Balancing Degree, Diameter and Weight in Euclidean Spanners

In this paper we devise a novel \emph{unified} construction of Euclidean spanners that trades between the maximum degree, diameter and weight gracefully. For a positive integer k, our construction provides a (1+eps)-spanner with maximum degree O(k), diameter O(log_k n + alpha(k)), weight O(k \cdot log_k n \cdot log n) \cdot w(MST(S)), and O(n) edges. Note that for k= n^{1/alpha(n)} this gives rise to diameter O(alpha(n)), weight O(n^{1/alpha(n)} \cdot log n \cdot alpha(n)) \cdot w(MST(S)) and maximum degree O(n^{1/alpha(n)}), which improves upon a classical result of Arya et al. \cite{ADMSS95}; in the corresponding result from \cite{ADMSS95} the spanner has the same number of edges and diameter, but its weight and degree may be arbitrarily large. Also, for k = O(1) this gives rise to maximum degree O(1), diameter O(log n) and weight O(log^2 n) \cdot w(MST(S)), which reproves another classical result of Arya et al. \cite{ADMSS95}. Our bound of O(log_k n + alpha(k)) on the diameter is optimal under the constraints that the maximum degree is O(k) and the number of edges is O(n). Our bound on the weight is optimal up to a factor of log n. Our construction also provides a similar tradeoff in the complementary range of parameters, i.e., when the weight should be smaller than log^2 n, but the diameter is allowed to grow beyond log n. For random point sets in the d-dimensional unit cube, we "shave" a factor of log n from the weight bound. Specifically, in this case our construction achieves maximum degree O(k), diameter O(log_k n + alpha(k)) and weight that is with high probability O(k \cdot log_k n) \cdot w(MST(S)). Finally, en route to these results we devise optimal constructions of 1-spanners for general tree metrics, which are of independent interest.

cs.CG↗

arXiv2010

Distributed Deterministic Edge Coloring using Bounded Neighborhood Independence

We study the {edge-coloring} problem in the message-passing model of distributed computing. This is one of the most fundamental and well-studied problems in this area. Currently, the best-known deterministic algorithms for (2Delta -1)-edge-coloring requires O(Delta) + log-star n time \cite{PR01}, where Delta is the maximum degree of the input graph. Also, recent results of \cite{BE10} for vertex-coloring imply that one can get an O(Delta)-edge-coloring in O(Delta^{epsilon} \cdot \log n) time, and an O(Delta^{1 + epsilon})-edge-coloring in O(log Delta log n) time, for an arbitrarily small constant epsilon > 0. In this paper we devise a drastically faster deterministic edge-coloring algorithm. Specifically, our algorithm computes an O(Delta)-edge-coloring in O(Delta^{epsilon}) + log-star n time, and an O(Delta^{1 + epsilon})-edge-coloring in O(log Delta) + log-star n time. This result improves the previous state-of-the-art {exponentially} in a wide range of Delta, specifically, for 2^{Omega(\log-star n)} \leq Delta \leq polylog(n). In addition, for small values of Delta our deterministic algorithm outperforms all the existing {randomized} algorithms for this problem. On our way to these results we study the {vertex-coloring} problem on the family of graphs with bounded {neighborhood independence}. This is a large family, which strictly includes line graphs of r-hypergraphs for any r = O(1), and graphs of bounded growth. We devise a very fast deterministic algorithm for vertex-coloring graphs with bounded neighborhood independence. This algorithm directly gives rise to our edge-coloring algorithms, which apply to {general} graphs. Our main technical contribution is a subroutine that computes an O(Delta/p)-defective p-vertex coloring of graphs with bounded neighborhood independence in O(p^2) + \log-star n time, for a parameter p, 1 \leq p \leq Delta.

cs.DC↗

arXiv2010

Deterministic Distributed Vertex Coloring in Polylogarithmic Time

Consider an n-vertex graph G = (V,E) of maximum degree Delta, and suppose that each vertex v \in V hosts a processor. The processors are allowed to communicate only with their neighbors in G. The communication is synchronous, i.e., it proceeds in discrete rounds. In the distributed vertex coloring problem the objective is to color G with Delta + 1, or slightly more than Delta + 1, colors using as few rounds of communication as possible. (The number of rounds of communication will be henceforth referred to as running time.) Efficient randomized algorithms for this problem are known for more than twenty years \cite{L86, ABI86}. Specifically, these algorithms produce a (Delta + 1)-coloring within O(log n) time, with high probability. On the other hand, the best known deterministic algorithm that requires polylogarithmic time employs O(Delta^2) colors. This algorithm was devised in a seminal FOCS'87 paper by Linial \cite{L87}. Its running time is O(log^* n). In the same paper Linial asked whether one can color with significantly less than Delta^2 colors in deterministic polylogarithmic time. By now this question of Linial became one of the most central long-standing open questions in this area. In this paper we answer this question in the affirmative, and devise a deterministic algorithm that employs Δ^{1 +o(1)} colors, and runs in polylogarithmic time. Specifically, the running time of our algorithm is O(f(Delta) log Delta log n), for an arbitrarily slow-growing function f(Delta) = ω(1). We can also produce O(Delta^{1 + η})-coloring in O(log Delta log n)-time, for an arbitrarily small constant η> 0, and O(Delta)-coloring in O(Delta^ε log n) time, for an arbitrarily small constant ε> 0.

cs.DC↗

arXiv2008

Distributed (Delta + 1)-coloring in linear (in Delta) time

The distributed (Delta + 1)-coloring problem is one of most fundamental and well-studied problems of Distributed Algorithms. Starting with the work of Cole and Vishkin in 86, there was a long line of gradually improving algorithms published. The current state-of-the-art running time is O(Delta log Delta + log^* n), due to Kuhn and Wattenhofer, PODC'06. Linial (FOCS'87) has proved a lower bound of 1/2 \log^* n for the problem, and Szegedy and Vishwanathan (STOC'93) provided a heuristic argument that shows that algorithms from a wide family of locally iterative algorithms are unlikely to achieve running time smaller than Θ(Delta log Delta). We present a deterministic (Delta + 1)-coloring distributed algorithm with running time O(Delta) + 1/2 log^* n. We also present a tradeoff between the running time and the number of colors, and devise an O(Delta * t)-coloring algorithm with running time O(Delta / t + \log^* n), for any parameter t, 1 < t < Delta^{1-epsilon}, for an arbitrarily small constant epsilon, 0 < epsilon < 1. On the way to this result we study a generalization of the notion of graph coloring, which is called defective coloring. In an m-defective p-coloring the vertices are colored with p colors so that each vertex has up to m neighbors with the same color. We show that an m-defective p-coloring with reasonably small m and p can be computed very efficiently. We also develop a technique to employ multiple defect colorings of various subgraphs of the original graph G for computing a (Delta+1)-coloring of G. We believe that these techniques are of independent interest.

cs.DC↗

arXiv2008

An Improved Construction of Progression-Free Sets

The problem of constructing dense subsets S of {1,2,..,n} that contain no arithmetic triple was introduced by Erdos and Turan in 1936. They have presented a construction with |S| = Ω(n^{\log_3 2}) elements. Their construction was improved by Salem and Spencer, and further improved by Behrend in 1946. The lower bound of Behrend is |S| = Omega({n \over {2^{2 \sqrt{2} \sqrt{\log_2 n}} \cdot \log^{1/4} n}}). Since then the problem became one of the most central, most fundamental, and most intensively studied problems in additive number theory. Nevertheless, no improvement of the lower bound of Behrend was reported since 1946. In this paper we present a construction that improves the result of Behrend by a factor of Theta(\sqrt{\log n}), and shows that |S| = Omega({n \over {2^{2 \sqrt{2} \sqrt{\log_2 n}}}} \cdot \log^{1/4} n). In particular, our result implies that the construction of Behrend is not optimal. Our construction and proof are elementary and self-contained.

math.NT↗

arXiv2008

Shallow, Low, and Light Trees, and Tight Lower Bounds for Euclidean Spanners

We show that for every $n$-point metric space $M$ there exists a spanning tree $T$ with unweighted diameter $O(\log n)$ and weight $ω(T) = O(\log n) \cdot ω(MST(M))$. Moreover, there is a designated point $rt$ such that for every point $v$, $dist_T(rt,v) \le (1+ε) \cdot dist_M(rt,v)$, for an arbitrarily small constant $ε> 0$. We extend this result, and provide a tradeoff between unweighted diameter and weight, and prove that this tradeoff is \emph{tight up to constant factors} in the entire range of parameters. These results enable us to settle a long-standing open question in Computational Geometry. In STOC'95 Arya et al. devised a construction of Euclidean Spanners with unweighted diameter $O(\log n)$ and weight $O(\log n) \cdot ω(MST(M))$. Ten years later in SODA'05 Agarwal et al. showed that this result is tight up to a factor of $O(\log \log n)$. We close this gap and show that the result of Arya et al. is tight up to constant factors.

cs.CG↗

arXiv2006

A near-optimal fully dynamic distributed algorithm for maintaining sparse spanners

In this paper we devise an extremely efficient fully dynamic distributed algorithm for maintaining sparse spanners. Our resuls also include the first fully dynamic centralized algorithm for the problem with non-trivial bounds for both incremental and decremental update. Finally, we devise a very efficient streaming algorithm for the problem.

cs.DS↗

arXiv2005

Lower-Stretch Spanning Trees

We prove that every weighted graph contains a spanning tree subgraph of average stretch O((log n log log n)^2). Moreover, we show how to construct such a tree in time O(m log^2 n).

cs.DS↗