Tight Bounds for Asynchronous Renaming

Motivated by the increasing need for fast distributed processing of large-scale graphs such as the Web graph and various social networks, we study a number of fundamental graph problems in the message-passing model, where we have k machines that jointly perform computation on an arbitrary n-node (typically, n > k) input graph. The graph is assumed to be randomly partitioned among the k ≥ 2 machines (a common implementation in many real world systems). The communication is point-to-point, and the goal is to minimize the time complexity i.e., the number of communication rounds, of solving various fundamental graph problems.We present lower bounds that quantify the fundamental time limitations of distributively solving graph problems. We first show a lower bound of Ω(n/k) rounds for computing a spanning tree (ST) of the input graph. This result also implies the same bound for other fundamental problems such as computing a minimum spanning tree (MST), breadth-first tree (BFS), and shortest paths tree (SPT). We also show an Ω(n/k2) lower bound for connectivity ST verification and other related problems. Our lower bounds develop and use new bounds in random-partition communication complexity.To complement our lower bounds, we also give algorithms for various fundamental graph problems, e.g., PageRank, MST, connectivity, ST verification, shortest paths, cuts, spanners, covering problems, densest subgraph, subgraph isomorphism, finding triangles, etc. We show that problems such as PageRank, MST, connectivity, and graph covering can be solved in O(n/k) time (the notation O hides polylog(n) factors and an additive polylog(n) term); this shows that one can achieve almost linear (in k) speedup, whereas for shortest paths, we present algorithms that run in O(n/Ok) time (for (1 + e)-factor approximation) and in O(n/k) time (for O(log n)-factor approximation) respectively.Our results are a step towards understanding the complexity of distributively solving large-scale graph problems.

Tight bounds on the minimum mean square error for the additive Gaussian noise channel are derived, when the input distribution is constrained to be ε-close to a Gaussian reference distribution in terms of the Kullback-Leibler divergence. The distributions that attain the bounds are shown be Gaussian whose means are identical to that of the reference distribution and whose covariance matrices are defined implicitly via systems of matrix equations. The estimator that attains the upper bound is identified as a minimax optimal estimator that is robust against deviations from the assumed prior. The lower bound is shown to provide a potentially tighter alternative to the Cramér-Rao bound. Both properties are illustrated with numerical examples.

Motivated by the increasing need to understand the distributed algorithmic foundations of large-scale graph computations, we study some fundamental graph problems in a message-passing model for distributed computing where $k \geq 2$ machines jointly perform computations on graphs with n nodes (typically, $n \gg k$). The input graph is assumed to be initially randomly partitioned among the k machines, a common implementation in many real-world systems. Communication is point-to-point, and the goal is to minimize the number of communication \em rounds of the computation. Our main contribution is the \em General Lower Bound Theorem, a theorem that can be used to show non-trivial lower bounds on the round complexity of distributed large-scale data computations. The General Lower Bound Theorem is established via an information-theoretic approach that relates the round complexity to the minimal amount of information required by machines to solve the problem. Our approach is generic and this theorem can be used in a cookbook fashion to show distributed lower bounds in the context of several problems, including non-graph problems. We present two applications by showing (almost) tight lower bounds for the round complexity of two fundamental graph problems, namely \em PageRank computation and \em triangle enumeration. Our approach, as demonstrated in the case of PageRank, can yield tight lower bounds for problems (including, and especially, under a stochastic partition of the input) where communication complexity techniques are not obvious. Our approach, as demonstrated in the case of triangle enumeration, can yield stronger round lower bounds as well as message-round tradeoffs compared to approaches that use communication complexity techniques. We then present distributed algorithms for PageRank and triangle enumeration with a round complexity that (almost) matches the respective lower bounds; these algorithms exhibit a round complexity which scales superlinearly in k , improving significantly over previous results for these problems [Klauck et al., SODA 2015]. Specifically, we show the following results: \beginitemize item \em PageRank: We show a lower bound of $\tildeOmega (n/k^2)$ rounds, and present a distributed algorithm that computes the PageRank of all the nodes of a graph in $\tildeO (n/k^2)$ rounds. item \em Triangle enumeration: We show that there exist graphs with m edges where any distributed algorithm requires $\tildeOmega (m/k^5/3 )$ rounds. This result also implies the first non-trivial lower bound of $\tildeOmega(n^1/3 )$ rounds for the \em congested clique model, which is tight up to logarithmic factors. We then present a distributed algorithm that enumerates all the triangles of a graph in $\tildeO (m/k^5/3 + n/k^4/3 )$ rounds. \enditemize

A noticeable fraction of Algorithms papers in the last few decades improve the running time of well-known algorithms for fundamental problems by logarithmic factors. For example, the {O}(n^2) dynamic programming solution to the Longest Common Subsequence problem (LCS) was improved to O(n^2/log^{2}n) in several ways and using a variety of ingenious tricks. This line of research, also known as the art of shaving log factors, lacks a tool for proving negative results. Specifically, how can we show that it is unlikely that LCS can be solved in time O(n^2/log^3n)?\nPerhaps the only approach for such results was suggested in a recent paper of Abboud, Hansen, Vassilevska W. and Williams (STOC'16). The authors blame the hardness of shaving logs on the hardness of solving satisfiability on boolean formulas (Formula-SAT) faster than exhaustive search. They show that an O(n^2/log^{1000} n) algorithm for LCS would imply a major advance in circuit lower bounds. Whether this approach can lead to tighter barriers was unclear.\nIn this paper, we push this approach to its limit and, in particular, prove that a well-known barrier from complexity theory stands in the way for shaving five additional log factors for fundamental combinatorial problems. For LCS, regular expression pattern matching, as well as the Fréchet distance problem from Computational Geometry, we show that an O(n^2/log^{7+epsilon}{n}) runtime would imply new Formula-SAT algorithms.\nOur main result is a reduction from SAT on formulas of size s over n variables to LCS on sequences of length N=2^{n/2} * s^{1+o(1)}. Our reduction is essentially as efficient as possible, and it greatly improves the previously known reduction for LCS with N=2^{n/2} * s^c, for some c >= 100.

Motivated by the increasing need for fast distributed processing of large-scale graphs such as the Web graph and various social networks, we study a message-passing distributed computing model for graph processing and present lower bounds and algorithms for several graph problems. This work is inspired by recent large-scale graph processing systems (e.g., Pregel and Giraph) which are designed based on the message-passing model of distributed computing. Our model consists of a point-to-point communication network of $k$ machines interconnected by bandwidth-restricted links. Communicating data between the machines is the costly operation (as opposed to local computation). The network is used to process an arbitrary $n$-node input graph (typically $n \gg k > 1$) that is randomly partitioned among the $k$ machines (a common implementation in many real world systems). Our goal is to study fundamental complexity bounds for solving graph problems in this model. We present techniques for obtaining lower bounds on the distributed time complexity. Our lower bounds develop and use new bounds in random-partition communication complexity. We first show a lower bound of $\Omega(n/k)$ rounds for computing a spanning tree (ST) of the input graph. This result also implies the same bound for other fundamental problems such as computing a minimum spanning tree (MST). We also show an $\Omega(n/k^2)$ lower bound for connectivity, ST verification and other related problems. We give algorithms for various fundamental graph problems in our model. We show that problems such as PageRank, MST, connectivity, and graph covering can be solved in $\tilde{O}(n/k)$ time, whereas for shortest paths, we present algorithms that run in $\tilde{O}(n/\sqrt{k})$ time (for $(1+\epsilon)$-factor approx.) and in $\tilde{O}(n/k)$ time (for $O(\log n)$-factor approx.) respectively.

Leader election is one of the fundamental problems in distributed computing. It calls for all nodes of a network to agree on a single node, called the leader. If the nodes of the network have distinct labels, then agreeing on a single node means that all nodes have to output the label of the elected leader. If the nodes of the network are anonymous, the task of leader election is formulated as follows: every node v of the network must output a simple path, which is coded as a sequence of port numbers, such that all these paths end at a common node, the leader. In this paper, we study deterministic leader election in anonymous trees.Our aim is to establish tradeoffs between the allocated time τ and the amount of information that has to be given a priori to the nodes to enable leader election in time τ in all trees for which leader election in this time is at all possible. Following the framework of algorithms with advice, this information (a single binary string) is provided to all nodes at the start by an oracle knowing the entire tree. The length of this string is called the size of advice. For a given time τ allocated to leader election, we give upper and lower bounds on the minimum size of advice sufficient to perform leader election in time τ.For most values of τ, our upper and lower bounds are either tight up to multiplicative constants, or they differ only by a logarithmic factor. Let T be an n-node tree of diameter diam ≤ D. While leader election in time diam can be performed without any advice, for time diam -- 1 we give tight upper and lower bounds of Θ(log D). For time diam -- 2 we give tight upper and lower bounds of Θ(log D) for even values of diam, and tight upper and lower bounds of Θ(log n) for odd values of diam. Moving to shorter time, in the interval [β · diam, diam -- 3] for constant β > 1/2, we prove an upper bound of O([EQUATION]) and a lower bound of Ω(n/D), the latter being valid whenever diam is odd or when the time is at most diam -- 4. Hence, with the exception of the special case when diam is even and time is exactly diam -- 3, our bounds leave only a logarithmic gap in this time interval. Finally, for time α · diam for any constant α

In Zheng et al. (J Comb Optim 30(2):360–369, 2015) modelled a surgery problem by the one-dimensional bin packing, and developed a semi-online algorithm to give an efficient feasible solution. In their algorithm they used a buffer to temporarily store items, having a possibility to lookahead in the list. Because of the considered practical problem they investigated the 2-parametric case, when the size of the items is at most 1 / 2. Using an NF-based online algorithm the authors proved an ACR of $$13/9 = 1.44\ldots $$ for any given buffer size not less than 1. They also gave a lower bound of $$4/3=1.33\ldots $$ for the bounded-space algorithms that use NF-based rules. Later, in Zhang et al. (J Comb Optim 33(2):530–542, 2017) an algorithm was given with an ACR of 1.4243, and the authors improved the lower bound to 1.4230. In this paper we present a tight lower bound of $$h_\infty (r)$$ for the r-parametric problem when the buffer capacity is 3. Since $$h_\infty (2) = 1.42312\ldots $$ , our result—as a special case—gives a tight bound for the algorithm-class given in 2017. To prove that the lower bound is tight, we present an NF-based online algorithm that considers the r-parametric problem, and uses a buffer with capacity of 3. We prove that this algorithm has an ACR that is equal to the lower bounds for arbitrary r.

We study the problem of determining the size of the smallest tile set in which a given target shape uniquely self-assembles in Winfree’s abstract Tile assembly Model (aTAM), an elegant combinatorial model of DNA tile self-assembly. This problem is also known as the directed tile complexity problem. We work in a variant of the aTAM, restricted to having the minimum binding strength threshold (temperature) set to 1 but mildly generalized to allow self-assembly to take place in a just-barely 3D setting, where unit cubes are allowed to be placed in the $$z=0$$ and $$z=1$$ planes. Furcy, Summers and Withers recently proved lower and upper bounds on the directed tile complexity of a just-barely 3D $$k \times N$$ rectangle at temperature-1 of $$\varOmega \left( N^{\frac{1}{k}}\right) $$ and $$O\left( N^{\frac{1}{k-1}}+\log N\right) $$ , respectively. However, their upper bound does not hold for $$k=2$$ . We close this gap for $$k=2$$ by proving an asymptotically tight bound of $$\varTheta (N)$$ on the directed tile complexity of a just-barely 3D $$2 \times N$$ rectangle at temperature-1. The proof of our lower bound is based on an algorithm that uses a novel projection of a given just-barely 3D assembly onto an equivalent, 2D assembly.

This paper deals with an abstraction of a unified problem of drug discovery and pathogen identification. Pathogen identification involves the identification of disease-causing biomolecules. Drug discovery involves finding chemical compounds, called lead compounds, that bind to pathogenic proteins and eventually inhibit the function of the protein. In this paper, the lead compounds are abstracted as inhibitors, pathogenic proteins as defectives, and the mixture of “ineffective” chemical compounds and non-pathogenic proteins as normal items. A defective could be immune to the presence of an inhibitor in a test. So, a test containing a defective is positive if it does not contain its “associated” inhibitor. The goal of this paper is to identify the defectives, inhibitors, and their “associations” with high probability, or in other words, learn the immune defectives graph (IDG) efficiently through group tests. We propose a probabilistic non-adaptive pooling design, a probabilistic two-stage adaptive pooling design, and decoding algorithms for learning the IDG. For the two-stage adaptive-pooling design, we show that the sample complexity of the number of tests required to guarantee recovery of the inhibitors, defectives, and their associations with high probability, i.e., the upper bound, exceeds the proposed lower bound by a logarithmic multiplicative factor in the number of items. To be precise, lower and upper bounds of Ω((r + d) log n + rd) and O(rd log n) tests, respectively, are identified for classifying r inhibitors and d defectives amongst n items, and identifying their associations. For the nonadaptive pooling design, we show that the upper bound (given by O((r + d) <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> log n) tests) exceeds the proposed lower bound (given by max{Q((r + d)logn + rd), Ω((r <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> /log r) log n), Ω(d <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sup> )} tests) by at most a logarithmic multiplicative factor in the number of items.

Improving TCP performance has long been the focus of many research efforts in mobile ad hoc networks (MANET). In this paper, we address one aspect of this endeavor: how to properly set TCP's congestion window limit (CWL) to achieve optimal performance. Past research has shown that using a small CWL improves TCP performance in certain scenarios [M. Gerla et al., Feb. 1999], [Z. Fu et al., Apr. 2003], however, no comprehensive study has been given. To this end, we turn the problem of setting TCP's optimal CWL into identifying the bandwidth-delay product (BDP) of a path in MANET. We first show and prove that, independent of the MAC layer protocol being used, the BDP of a path in MANET cannot exceed the round-trip hop-count (RTHC) of the path. We further refine this upper bound based on the IEEE 802.11 MAC layer protocol, and show that in a chain topology, a tighter upper bound exists, which is approximately 1/5 of the RTHC of the path. Based on this tighter bound, we propose an adaptive CWL setting strategy to dynamically adjust TCP's CWL according to the current RTHC of its path. Using ns-2 simulations, we show that our simple strategy improves TCP performance by 8% to 16% in a dynamic MANET environment.

This paper proposes an upper bound for mine productivity (useful for long-term planning) and also a simple truck dispatch rule (useful for short-term operations) that demonstrates how tight the upper bound can be using a simulation. It also proposes a greedy search to approximate the productivity upper bound, which is faster and often exact. Uncertainty is added to the simulation in order to verify how the productivity responds to it. Typically, the productivity’s upper bound is less tight close to its saturation point as a function of the number of trucks, where adding more trucks only increases queues. Furthermore, more uncertainty in the model typically leads to a less tight upper bound. The results conducted using real data from an open pit mine in Brazil show that the gap between the productivity upper bound and the productivity realization using the proposed dispatch rule for a homogeneous fleet can be less than 2%, but it can be as large as 12% near the productivity saturation point without uncertainty. Even though this gap seems to become arbitrarily small as the number of trucks and the simulation horizon increase, the productivity upper bound is never violated, which validates it as an upper bound and induces optimality for the dispatch rule.

In this letter, we obtain lower and upper bounds on the minimum distance $d_{\min }$ of low-density parity-check (LDPC) codes. The bounds are derived by categorizing the non-zero code words of an LDPC code into two categories of elementary and non-elementary. The first category contains code words whose induced subgraph has only degree-2 check nodes. We propose an efficient search algorithm that can find the elementary code words of an LDPC code with weight less than a certain value $a_{\max }$ , exhaustively. We also derive a lower bound $L_{ne}$ on the weight of non-elementary code words. By performing the search with $a_{\max } = L_{ne}$ , we either obtain an elementary code word with the smallest weight $d_{\min }$ , or establish the lower bound of $L_{ne}$ on $d_{\min }$ . For the upper bound, we modify our search algorithm to reach elementary codewords of larger weights at the cost of being non-exhaustive. Once such a codeword is found, its weight acts as an upper bound on $d_{\min }$ . We examine a large number of regular and irregular LDPC codes, and demonstrate the efficiency and versatility of our technique in finding lower and upper bounds on, and in many cases the exact value of, $d_{\min }$ . Finding $d_{\min }$ , or establishing search-based lower or upper bounds, for many of the examined codes are out of the reach of any existing algorithm.

We prove tight and near-tight combinatorial complexity bounds for vertical decompositions of arrangements of linear surfaces in four dimensions. In particular, we prove a tight upper bound of Θ(n 4) for the vertical decomposition of an arrangement of n hyperplanes in four dimensions, improving the best previously known bound [] by a logarithmic factor. We also show that the complexity of the vertical decomposition of an arrangement of n 3-simplices in four dimensions is O(n 4α(n) log n), improving the best previously known bound [] by a near-linear factor. We believe that the techniques used for obtaining these results can also be extended to analyze decompositions of arrangements of fixed-degree algebraic surfaces (or surface patches) in four dimensions.

We consider computing a longest palindrome in the streaming model, where the symbols arrive one-by-one and we do not have random access to the input. While computing the answer exactly using sublinear space is not possible in such a setting, one can still hope for a good approximation guarantee. Our contribution is twofold. First, we provide lower bounds on the space requirements for randomized approximation algorithms processing inputs of length n. We rule out Las Vegas algorithms, as they cannot achieve sublinear space complexity. For Monte Carlo algorithms, we prove a lower bounds of Omega(M log min {|Sigma|, M}) bits of memory; here M=n/E for approximating the answer with additive error E, and M= log n / log (1 + epsilon) for approximating the answer with multiplicative error (1 + epsilon). Second, we design three real-time algorithms for this problem. Our Monte Carlo approximation algorithms for both additive and multiplicative versions of the problem use O(M) words of memory. Thus the obtained lower bounds are asymptotically tight up to a logarithmic factor. The third algorithm is deterministic and finds a longest palindrome exactly if it is short. This algorithm can be run in parallel with a Monte Carlo algorithm to obtain better results in practice. Overall, both the time and space complexity of finding a longest palindrome in a stream are essentially settled.

Energy consumption is a significant factor in wireless networks with battery-powered nodes and transceivers as a dominant energy consumer .Also mutual exclusion is a fundamental problem in distributed systems.“Mutual exclusion” allows only one process at a time to access the shared resource and the others have to be locked and wait for their turns.. Retaining mutual exclusion, is proposed as a solution to guarantee the correctness of read/written information from/in the shared resource or critical sections (CS).Wireless Network is an unstable network formed dynamically by a connection of wireless mobile nodes without the use of an existing network substructure. Since energy consumption during communication is a major depletion parameter the number of communication must be reduced as much as possible to achieve extended battery life. Since battery technology does not grow as rapidly as CPU or memory does so there is a strong need for the presence of protocols which are as energy efficient as effective.In this paper we present a new fully distributed token–based mutual-exclusion algorithm for clustered Mobile ad-hoc network with message count reduction purpose which eventuates to power optimization. Therefore we use Raymond's algorithm (which is well-known in stepping down message complexity) within the clusters and perpetual Mobility of token (that is so efficient in high load network such as Manet's) between the clusters.