Tight Lower Bounds for Central String Queries in Compressed Space

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.

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.

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.

We study networks that can sort n, items even when a large number of the comparators in the network are faulty. We restrict our attention to networks that consist of registers, comparators, and replicators. ( Replicators are used to copy an item from one register to another, and they are assumed to be fault free.) We consider the scenario of both random and worst-case comparator faults, and we follow the general model of destructive comparator failure proposed by Assaf and Upfal [ Proc. 31st IEEE Symposium on Foundations of Computer Science, St. Louis, MO, 1990, pp. 275--284] in which the two outputs of a faulty comparator can fail independently of each other. In the case of random faults, Assaf and Upfal showed how to construct a network with O(n log2n ) comparators that (with high probability) can sort n items even if a constant fraction of the comparators are faulty. Whether the bound on the number of comparators can be improved (to, say, O(n log n)) for sorting (or merging) has remained an interesting open question. We resolve this question in this paper by proving that any n-item sorting or merging network which can tolerate a constant fraction of random failures has $\Omega(n \log^2 n)$ comparators. In the case of worst-case faults, we show that $\Omega(kn \log n)$ comparators are necessary to construct a sorting or merging network that can tolerate up to k worst-case faults. We also show that this bound is tight for k = O(log n). The lower bound is particularly significant since it formally proves that the cost of being tolerant to worst-case failures is very high. Both the lower bound for random faults and the lower bound for worst-case faults are the first nontrivial lower bounds on the size of a fault-tolerant sorting or merging network.

This article presents the first tight bounds on the time complexity of shared-memory renaming, a fundamental problem in distributed computing in which a set of processes need to pick distinct identifiers from a small namespace. We first prove an individual lower bound of Ω( k ) process steps for deterministic renaming into any namespace of size subexponential in k , where k is the number of participants. The bound is tight: it draws an exponential separation between deterministic and randomized solutions, and implies new tight bounds for deterministic concurrent fetch-and-increment counters, queues, and stacks. The proof is based on a new reduction from renaming to another fundamental problem in distributed computing: mutual exclusion. We complement this individual bound with a global lower bound of Ω( k log ( k / c )) on the total step complexity of renaming into a namespace of size ck , for any c ≥ 1. This result applies to randomized algorithms against a strong adversary, and helps derive new global lower bounds for randomized approximate counter implementations, that are tight within logarithmic factors. On the algorithmic side, we give a protocol that transforms any sorting network into a randomized strong adaptive renaming algorithm, with expected cost equal to the depth of the sorting network. This gives a tight adaptive renaming algorithm with expected step complexity O (log k ), where k is the contention in the current execution. This algorithm is the first to achieve sublinear time, and it is time-optimal as per our randomized lower bound. Finally, we use this renaming protocol to build monotone-consistent counters with logarithmic step complexity and linearizable fetch-and-increment registers with polylogarithmic cost.

Given an integerk, and anarbitrary integer greater than\(2^{2^k } \), we prove a tight bound of\(\Theta (\sqrt k )\) on the time required to compute\(2^{2^k } \) with operations {+, −, *, /, ⌊·⌋, ≤}, and constants {0, 1}. In contrast, when the floor operation is not available this computation requires Ω(k) time. Using the upper bound, we give an\(O(\sqrt {\log n} )\) time algorithm for computing ⌊log loga⌋, for alln-bit integersa. This upper bound matches the lower bound for computing this function given by Mansour, Schieber, and Tiwari. To the best of our knowledge these are the first non-constant tight bounds for computations involving the floor operation.

In This Issue

In this paper we consider the minimum feedback vertex set problem in graphs, i.e., the problem of finding a minimal cardinality subset of the vertices, whose removal makes a graph acyclic. The problem is \({\cal NP}\)-hard for general topologies, but optimal and near-optimal solutions have been provided for particular networks. We improve the upper bounds of [11] both for the two-dimensional mesh of trees, and for the pyramid networks. We also present upper and lower bounds for other topologies: the higher-dimensional meshes of trees, and the trees of meshes networks. For the two-dimensional meshes of trees the results are optimal; for the higher-dimensional meshes of trees and the tree of meshes the results are asymptotically optimal. For the pyramid networks, the presented upper bound almost matches the lower bound of [11].

In his seminal work, Cleve [STOC '86] proved that the bias of any coin-flipping protocol is inversely proportional to the number of rounds. This lower bound was met for the two-party case by Moran et al. [Journal of Cryptology '16], and the three-party case (up to a polylogarithmic factor) by Haitner and Tsfadia [SICOMP '17], and was approached for multi-party protocols by Haitner et al. [SODA '17] when the number of rounds is at least doubly exponential in the number of parties. For the complement case, however, the best bias for multi-party coin-flipping protocols is proportional to the number of parties and inversely proportional to the square root of the number of rounds. The latter bias is achieved by the majority protocol of Awerbuch et al. [Manuscript '85]. Our main result is a tighter lower bound on the bias of coin-flipping protocols, showing that, if the number of rounds is bounded by some polynomial in the number of parties, then the bias is lower-bounded by a quantity that is inversely proportional to the square root of the number of rounds (up to a polylogarithmic factor). As far as we know, this is the first improvement of Cleve's bound, and is far from the aforementioned upper bound of Awerbuch et al. only by a factor of the number of parties. We prove the above bound using two new results that we believe are of independent interest. The first result is that a sequence of (augmented) weak martingales have large gap: with constant probability there exists two adjacent variables whose gap is at least the ratio between the gap between the first and last variables and the square root of the number of variables. This generalizes over the result of Cleve and Impagliazzo [Manuscript '93], who showed that the above holds for strong martingales, and allows in some setting to exploit this gap by efficient algorithms. We prove the above using a novel argument that does not follow the more complicated approach of Cleve and Impagliazzo. The second result is a new sampling algorithm that uses a differentially private mechanism to minimize the effect of data divergence.

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.

Coordinate interleaved orthogonal designs (CIOD) (Khan and Rajan in IEEE Trans Inform Theory 52(5):2062---2091, 2006) can offer desirable properties, such as full rate, full diversity and single-symbol maximum likelihood decoding for two, three and four transmit antennas under quasi-static fading channels. When fading is time-selective, zero-forcing decoder can applied to achieve good performance while still maintain low decoding complexity. In this paper, theoretical analysis of symbol error rate performance for CIOD codes over time-selective fading channels with a zero-forcing linear receiver is derived. Firstly, a closed-form expression (i.e., not in integral form) is derived for the average symbol pair-wise error probability (SPEP) in time-selective frequency-nonselective independent identically distributed (i.i.d.) Rayleigh fading channels. Then, the SPEP is used to derive a tight upper bound (UB) for the symbol-error rate (SER) of CIOD codes. Simulation results indicate that our theoretical UB often coincides (within 0.05 dB) with the true SER obtained via Monte-Carlo simulation. The UB can thus be used to accurately predict and optimize the performance of CIOD codes over time-selective fading channels.

Distributed applications generate a significant amount of network traffic. By collocating frequently communicating nodes (e.g., virtual machines) on the same clusters (e.g., server or rack), we can reduce the network load and improve application performance. However, the communication pattern of different applications is often unknown a priori and may change over time, hence it needs to be learned in an online manner. This paper revisits the online balanced partitioning problem that asks for an algorithm that strikes an optimal tradeoff between the benefits of collocation (i.e., lower network load) and its costs (i.e., migrations). Our first contribution is a significantly improved deterministic lower bound of Ω(k • l) on the competitive ratio, where l is the number of clusters and k is the cluster size, even for a scenario in which the communication pattern is static and can be perfectly partitioned; we also provide an asymptotically tight upper bound of O(k•l) for this scenario. For k = 3, we contribute an asymptotically tight upper bound of Θ(l) for the general model in which the communication pattern can change arbitrarily over time. We improve the result for k = 2 by providing a strictly 6-competitive upper bound for the general model.

Distributed applications, including batch processing, streaming, scale-out databases, or machine learning, generate a significant amount of network traffic. By collocating frequently communicating nodes (e.g., virtual machines) on the same clusters (e.g., server or rack), we can reduce the network load and improve application performance. However, the communication pattern of different applications is often unknown a priori and may change over time, hence it needs to be learned in an online manner. This paper revisits the online balanced partitioning problem (introduced by Avin et al. at DISC 2016) that asks for an algorithm that strikes an optimal tradeoff between the benefits of collocation (i.e., lower network load) and its costs (i.e., migrations). Our first contribution is a significantly improved deterministic lower bound of Ω(k · e) on the competitive ratio, where e is the number of clusters and k is the cluster size, even for a scenario in which the communication pattern is static and can be perfectly partitioned; we also provide an asymptotically tight upper bound of O(k · e) for this scenario. For k = 3, we contribute an asymptotically tight upper bound of Θ(e) for the general model in which the communication pattern can change arbitrarily over time. In contrast to most prior work, our algorithms respect all capacity constraints and do not require resource augmentation.