Priority Queues with Multiple Time Fingers

A priority queue is presented that supports the operations insert and find-min in worst-case constant time, and delete and delete-min on element x in worst-case O(lg(min{w_x, q_x}+2)) time, where w_x (respectively q_x) is the number of elements inserted after x (respectively before x) and are still present at the time of the deletion of x. Our priority queue then has both the working-set and the queueish properties, and more strongly it satisfies these properties in the worst-case sense. We also define a new distribution-sensitive property---the time-finger property, which encapsulates and generalizes both the working-set and queueish properties, and present a priority queue that satisfies this property. In addition, we prove a strong implication that the working-set property is equivalent to the unified bound (which is the minimum per operation among the static finger, static optimality, and the working-set bounds). This latter result is of tremendous interest by itself as it had gone unnoticed since the introduction of such bounds by Sleater and Tarjan [JACM 1985]. Accordingly, our priority queue satisfies other distribution-sensitive properties as the static finger, static optimality, and the unified bound.Comment: 14 pages, 4 figure

On the Error in Phase Transition Computations for Compressed Sensing

Evaluating the statistical dimension is a common tool to determine the asymptotic phase transition in compressed sensing problems with Gaussian ensemble. Unfortunately, the exact evaluation of the statistical dimension is very difficult and it has become standard to replace it with an upper-bound. To ensure that this technique is suitable, [1] has introduced an upper-bound on the gap between the statistical dimension and its approximation. In this work, we first show that the error bound in [1] in some low-dimensional models such as total variation and $\ell_1$ analysis minimization becomes poorly large. Next, we develop a new error bound which significantly improves the estimation gap compared to [1]. In particular, unlike the bound in [1] that is not applicable to settings with overcomplete dictionaries, our bound exhibits a decaying behavior in such cases

Succinct Representation of Trees and Graphs

In this thesis, we study succinct representations of trees and graphs. A succinct representation of a combinatorial object is a space efficient representation that supports a reasonable set of operations and queries on the object in constant or near constant time on the RAM with logarithmic word size. The storage requirement of a succinct representation is intended to be optimal to within lower order terms. We first propose a uniform approach for succinct representation of various families of trees. The method is based on two recursive decompositions of trees into subtrees. The approach simplifies the existing representation of ordinal trees while allowing the full set of navigational operations and queries. The approach applied to cardinal (i.e., k-ary) trees yields a space-optimal succinct representation allowing cardinal-type operations (e.g., determining child labeled i) as well as the full set of ordinal-type operations (e.g., reporting the number of siblings to the left of a node). Previous space-optimal succinct representations had not been able to support both types of operations efficiently. We demonstrate how the approach can be applied to obtain a space-optimal succinct representation for the family of free trees where the order of children is insignificant. Furthermore, we show that our approach can be used to obtain entropy-based succinct representations. The approach adapts to match the degree-distribution entropy suggested by Jansson et al. We discuss that our approach can be made adaptive to various other entropy measures. Next, we focus on ordinal trees, and present a novel universal succinct representation. Our new representation is able to simultaneously emulate previous ordinal tree representations of the balanced parenthesis (BP), depth first unary degree sequence (DFUDS) and partitioned representations using a single instance of the data structure. They not only support the union of all the ordinal tree operations supported by these representations, but will also automatically inherit any new operations supported by these representations in the future; hence the universality title we attributed to the representation. We then move to more general graphs rather than trees, and consider the problem of encoding a graph with $n$ vertices and m edges compactly supporting adjacency, neighborhood and degree queries in constant time. The adjacency query asks whether there is an edge between two vertices, the neighborhood query reports the neighbors of a given vertex in constant time per neighbor, and the degree query reports the number of edges incident to a given vertex. The representation is to achieve the optimal space requirement as a function of n and m to within lower order terms. We prove a lower bound in the cell probe model that it is impossible to achieve the information theoretic lower bound to within lower order terms unless the graph is too sparse (namely, $m=o(n^\delta)$ for any constant \delta > 0) or too dense (namely m = \littleOmega{n^{2-\delta}}) for any constant \delta > 0). We also present a succinct encoding for graphs for all values of n,m supporting queries in constant time. The space requirement of the representation is always within a multiplicative 1+\epsilon factor of the information-theory lower bound for any constant $\epsilon > 0$. This is the best achievable space bound according to our lower bound where it applies. The space requirement of the representation achieves the information-theory lower bound tightly to within lower order terms when the graph is sparse (m=o(n^\delta) for any constant \delta > 0), or very dense (m = \littleOmega (n^2/(\sqrt{\log n}))

Cache-Oblivious Searching and Sorting in Multisets

We study three problems related to searching and sorting in multisets in the cache-oblivious model: Finding the most frequent element (the mode), duplicate elimination and finally multi-sorting. We are interested in minimizing the cache complexity (or number of cache misses) of algorithms for these problems in the context under which the cache size and block size are unknown. We start by showing the lower bounds in the comparison model. Then we present the lower bounds in the cache-aware model, which are also the lower bounds in the cache-oblivious model. We consider the input multiset of size N with multiplicities N1,. . . , Nk. The lower bound for the cache complexity of determining the mode is Ω({N over B} log {M over B} {N over fB}) where ƒ is the frequency of the mode and M, B are the cache size and block size respectively. Cache complexities of duplicate removal and multi-sorting have lower bounds of Ω({N over B} log {M over B} {N over B} - £{k over i}=1{Ni over B}log {M over B} {Ni over B}). We present two deterministic approaches to give algorithms: selection and distribution. The algorithms with these deterministic approaches differ from the lower bounds by at most an additive term of {N over B} loglog M. However, since loglog M is very small in real applications, the gap is tiny. Nevertheless, the ideas of our deterministic algorithms can be used to design cache-aware algorithms for these problems. The algorithms turn out to be simpler than the previously-known cache-aware algorithms for these problems. Another approach to design algorithms for these problems is the probabilistic approach. In contrast to the deterministic algorithms, our randomized cache-oblivious algorithms are all optimal and their cache complexities exactly match the lower bounds. All of our algorithms are within a constant factor of optimal in terms of the number of comparisons they perform