Results 1 
7 of
7
SHOFA: Robust compressive sensing with orderoptimal complexity, measurements, and bits
"... Suppose x is any exactly ksparse vector in �n. We present a class of “sparse” matrices A, and a corresponding algorithm that we call SHOFA (for Short and Fast1) that, with high probability over A, can reconstruct x from Ax. The SHOFA algorithm is related to the Invertible Bloom Lookup Tables (IBL ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
Suppose x is any exactly ksparse vector in �n. We present a class of “sparse” matrices A, and a corresponding algorithm that we call SHOFA (for Short and Fast1) that, with high probability over A, can reconstruct x from Ax. The SHOFA algorithm is related to the Invertible Bloom Lookup Tables (IBLTs) recently introduced by Goodrich et al., with two important distinctions – SHOFA relies on linear measurements, and is robust to noise and approximate sparsity. The SHOFA algorithm is the first to simultaneously have the following properties: (a) it requires only O(k) measurements, (b) the bitprecision of each measurement and each arithmetic operation is O (log(n) + P) (here 2 −P corresponds to the desired relative error in the reconstruction of x), (c) the computational complexity of decoding is O(k) arithmetic operations, and (d) if the reconstruction goal is simply to recover a single component of x instead of all of x, with high probability over A this can be done in constant time. All constants above are independent of all problem parameters other than the desired probability of success. For a wide range of parameters these properties are informationtheoretically orderoptimal. In addition, our SHOFA algorithm is robust to random noise, and (random) approximate sparsity for a large range of k. In particular, suppose the measured vector equals A(x+z)+e, where z and e correspond respectively to the source tail and measurement noise. Under reasonable statistical assumptions on z and e our decoding algorithm reconstructs x with an estimation error of O(z1 + (log k) 2 e1). The SHOFA algorithm works with high probability over A, z, and e, and still requires only O(k) steps and O(k) measurements over O(log(n))bit numbers. This is in contrast to most existing algorithms which focus on the “worstcase" z model, where it is known Ω(k log(n/k)) measurements over O(log(n))bit numbers are necessary.
Peeling Arguments and Double Hashing
"... The analysis of several algorithms and data structures can be reduced to the analysis of the following greedy “peeling” process: start with a random hypergraph; find a vertex of degree at most k, and remove it and all of its adjacent hyperedges from the graph; repeat until there is no suitable vert ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
The analysis of several algorithms and data structures can be reduced to the analysis of the following greedy “peeling” process: start with a random hypergraph; find a vertex of degree at most k, and remove it and all of its adjacent hyperedges from the graph; repeat until there is no suitable vertex. This specific process finds the kcore of a hypergraph, and variations on this theme have proven useful in analyzing for example decoding from lowdensity paritycheck codes, several hashbased data structures such as cuckoo hashing, and algorithms for satisfiability of random formulae. This approach can be analyzed several ways, with two common approaches being via a corresponding branching process or a fluid limit family of differential equations. In this paper, we make note of an interesting aspect of these types of processes: the results are generally the same when the randomness is structured in the manner of double hashing. This phenomenon allows us to use less randomness and simplify the implementation for several hashbased data structures and algorithms. We explore this approach from both an empirical and theoretical perspective, examining theoretical justifications as well as simulation results for specific problems.
3 Finite Length Analysis on Listing Failure Probability of Invertible Bloom Lookup Tables
"... ar ..."
Subspace Synchronization: A NetworkCoding Approach to Object Reconciliation
"... AbstractAssume that two users possess two different subspaces of an ambient linear space. We show that the problem of synchronization of such vector spaces can be easily solved by an efficient algorithm. By building on this observation, we propose an algorithm for synchronization of two collection ..."
Abstract
 Add to MetaCart
(Show Context)
AbstractAssume that two users possess two different subspaces of an ambient linear space. We show that the problem of synchronization of such vector spaces can be easily solved by an efficient algorithm. By building on this observation, we propose an algorithm for synchronization of two collections of binary files of length n each, stored in the cloud in a distributed manner. By further employing techniques akin to network coding, we propose a more efficient file synchronization algorithm that has communication complexity O(d · n) bits and computational complexity O(k 2 · n) operations, where k is the total number of files and d is the number of files that differ. The algorithm successfully reconciles two sets of files in 3 communication rounds with high probability.
Finite Length Analysis on Listing Failure Probability of Invertible Bloom Lookup Tables
, 2013
"... ..."
Hardness of Peeling with Stashes
, 2014
"... The analysis of several algorithms and data structures can be framed as a peeling process on a random hypergraph: vertices with degree less than k and their adjacent edges are removed until no vertices of degree less than k are left. Often the question is whether the remaining hypergraph, the kcore ..."
Abstract
 Add to MetaCart
(Show Context)
The analysis of several algorithms and data structures can be framed as a peeling process on a random hypergraph: vertices with degree less than k and their adjacent edges are removed until no vertices of degree less than k are left. Often the question is whether the remaining hypergraph, the kcore, is empty or not. In some settings, it may be possible to remove either vertices or edges from the hypergraph before peeling, at some cost. For example, in hashing applications where keys correspond to edges and buckets to vertices, one might use an additional side data structure, commonly referred to as a stash, to separately handle some keys in order to avoid collisions. The natural question in such cases is to find the minimum number of edges (or vertices) that need to be stashed in order to realize an empty kcore. We show that both these problems are NPcomplete for all k ≥ 2 on graphs and regular hypergraphs, with the sole exception being that the edge variant of stashing is solvable in polynomial time for k = 2 on standard (2uniform) graphs.
CacheOblivious Peeling of Random Hypergraphs∗
"... The computation of a peeling order in a randomly generated hypergraph is the most timeconsuming step in a number of constructions, such as perfect hashing schemes, random rSAT solvers, errorcorrecting codes, and approximate set encodings. While there exists a straightforward linear time algorithm ..."
Abstract
 Add to MetaCart
(Show Context)
The computation of a peeling order in a randomly generated hypergraph is the most timeconsuming step in a number of constructions, such as perfect hashing schemes, random rSAT solvers, errorcorrecting codes, and approximate set encodings. While there exists a straightforward linear time algorithm, its poor I/O performance makes it impractical for hypergraphs whose size exceeds the available internal memory. We show how to reduce the computation of a peeling order to a small number of sequential scans and sorts, and analyze its I/O complexity in the cacheoblivious model. The resulting algorithm requires O(sort(n)) I/Os and O(n logn) time to peel a random hypergraph with n edges. We experimentally evaluate the performance of our implementation of this algorithm in a realworld scenario by using the construction of minimal perfect hash functions (MPHF) as our test case: our algorithm builds a MPHF of 7.6 billion keys in less than 21 hours on a single machine. The resulting data structure is both more spaceefficient and faster than that obtained with the current stateoftheart MPHF construction for largescale key sets.