Martin Dietzfelbinger

A Reliable Randomized Algorithm for the Closest-Pair Problem

The following two computational problems are studied:Duplicate grouping:Assume thatnitems are given, each of which is labeled by an integer key from the set {0,?,U?1}. Store the items in an array of sizensuch that items with the same key occupy a contiguous segment of the array.Closest pair:Assume that a multiset ofnpoints in thed-dimensional Euclidean space is given, whered?1 is a fixed integer. Each point is represented as ad-tuple of integers in the range {0,?,U?1} (or of arbitrary real numbers). Find a closest pair, i.e., a pair of points whose distance is minimal over all such pairs.In 1976, Rabin described a randomized algorithm for the closest-pair problem that takes linear expected time. As a subroutine, he used a hashing procedure whose implementation was left open. Only years later randomized hashing schemes suitable for filling this gap were developed.In this paper, we return to Rabins classic algorithm to provide a fully detailed description and analysis, thereby also extending and strengthening his result. As a preliminary step, we study randomized algorithms for the duplicate-grouping problem. In the course of solving the duplicate-grouping problem, we describe a new universal class of hash functions of independent interest.It is shown that both of the foregoing problems can be solved by randomized algorithms that useO(n) space and finish inO(n) time with probability tending to 1 asngrows to infinity. The model of computation is a unit-cost RAM capable of generating random numbers and of performing arithmetic operations from the set {+,?,?,div,log2,exp2}, wheredivdenotes integer division andlog2andexp2are the mappings from N to N?{0} withlog2(m)=?log2m? andexp2(m)=2mfor allm?N. If the operationslog2andexp2are not available, the running time of the algorithms increases by an additive term ofO(loglogU). All numbers manipulated by the algorithms consist ofO(logn+logU) bits.The algorithms for both of the problems exceed the time boundO(n) orO(n+loglogU) with probability 2?n?(1). Variants of the algorithms are also given that use onlyO(logn+logU) random bits and have probabilityO(n??) of exceeding the time bounds, where ??1 is a constant that can be chosen arbitrarily.The algorithms for the closest-pair problem also works if the coordinates of the points are arbitrary real numbers, provided that the RAM is able to perform arithmetic operations from {+,?,?,div} on real numbers, whereadivbnow means ?a/b?. In this case, the running time isO(n) withlog2andexp2andO(n+loglog(?max/?max)) without them, where ?maxis the maximum and ?minis the minimum distance between any two distinct input points.

Dynamic perfect hashing: upper and lower bounds

A randomized algorithm is given for the dictionary problem with O(1) worst-case time for lookup and O(1) amortized expected time for insertion and deletion. An Omega (log n) lower bound is proved for the amortized worst-case time complexity of any deterministic algorithm in a class of algorithms encompassing realistic hashing-based schemes. If the worst-case lookup time is restricted to k, then the lower bound for insertion becomes Omega (kn/sup 1/k/).<<ETX>>

Universal Hashing and k-Wise Independent Random Variables via Integer Arithmetic without Primes

Let u, m≥1 be arbitrary integers and let k≥u. The central result of this paper is that the multiset H={itha,b¦0≤a, b<km} of functions from U=0,..., u }-1 to M={0,..., m −1, where h a,b (x)=((ax+b) mod km) div k, for x∈ U, is a (c, 2)-universal class of hash functions from U to M in the sense of Carter and Wegman [7, 25], with c=5/4. More precisely, we show that if x1, x2 are distinct elements of U and i1,i2∈ M are arbitrary, and if h is chosen at random from H, then ¦Prob (h(x1)=i1 ∧ h(x2)=i2-1/m2¦≤(1/2km)2≤1/4m2. Among the many known constructions of (c, 2)-universal classes there was none that would get by with such a small number of pure integer arithmetic operations without the assumption that a prime number of size the order of¦U¦ or at least ¦M¦ was available. — Varying this result, we obtain: (a) two-independent sequences of random variables; (b) universal hash classes of higher degree (“(c, l)-universal” classes) and l-wise independent random variables, for l ≥ 2; (c) algorithms for static and dynamic perfect hashing with an optimal number of random bits; all using pure integer arithmetic without the need for providing prime numbers (arbitrary or random) of a certain size. It should be noted that the focus here is not on minimizing the size of the probability space used, as in much of the recent work on “almost k-independent random variables”, but on the realization of such variables or hash classes using the most natural and most widely available operations, viz., integer arithmetic.

Tight thresholds for cuckoo hashing via XORSAT

We settle the question of tight thresholds for offline cuckoo hashing. The problem can be stated as follows: we have n keys to be hashed into m buckets each capable of holding a single key. Each key has k ≥ 3 (distinct) associated buckets chosen uniformly at random and independently of the choices of other keys. A hash table can be constructed successfully if each key can be placed into one of its buckets. We seek thresholds ck such that, as n goes to infinity, if n/m ≤ c for some c ck a hash table cannot be constructed successfully with high probability. Here we are considering the offline version of the problem, where all keys and hash values are given, so the problem is equivalent to previous models of multiple-choice hashing. We find the thresholds for all values of k > 2 by showing that they are in fact the same as the previously known thresholds for the random k-XORSAT problem.We then extend these results to the setting where keys can have differing number of choices, and make a conjecture (based on experimental observations) that extends our result to cuckoo hash tables storing multiple keys in a bucket.

A new universal class of hash functions and dynamic hashing in real time

The paper presents a new universal class of hash functions which have many desirable features of random functions, but can be (probabilistically) constructed using sublinear time and space, and can be evaluated in constant time.

Hash, Displace, and Compress

A hash function h, i.e., a function from the set U of all keys to the range range [m] = {0,...,m − 1} is called a perfect hash function (PHF) for a subset S ⊆ U of size n ≤ m if h is 1-1 on S. The important performance parameters of a PHF are representation size, evaluation time and construction time. In this paper, we present an algorithm that permits to obtain PHFs with expected representation size very close to optimal while retaining O(n) expected construction time and O(1) evaluation time in the worst case. For example in the case m = 1.23n we obtain a PHF that uses space 1.4 bits per key, and for m = 1.01n we obtain space 1.98 bits per key, which was not achievable with previously known methods. Our algorithm is inspired by several known algorithms; the main new feature is that we combine a modification of Pagh’s “hash-and-displace” approach with data compression on a sequence of hash function indices. Our algorithm can also be used for k-perfect hashing, where at most k keys may be mapped to the same value.

Polynomial hash functions are reliable

Polynomial hash functions are well studied and widely used in various applications. They have gained popularity because of certain performances they exhibit. It has been shown that even linear hash functions are expected to have such performances. However, quite often we would like the hash functions to be reliable, meaning that they perform well with high probability; for some certain important properties even higher degree polynomials were not known to be reliable. We show that for certain important properties linear hash functions are not reliable. We give indication that quadratic hash functions might not be reliable. On the positive side, we prove that cubic hash functions are reliable. In a more general setting, we show that higher degree of the polynomial hash functions translates into higher reliability. We also introduce a new class of hash functions, which enables to reduce the universe size in an efficient and simple manner. The reliability results and the new class of hash functions are used for some fundamental applications: improved and simplified reliable algorithms for perfect hash functions and real-time dictionaries, which use significantly less random bits, and tighter upper bound for the program size of perfect hash functions.

Simple, efficient shared memory simulations

We present three shared memory simulations on distributed memory machines (D MMs), which use universal hashing to dietribute the shared memory cells over the memory modules of the DMM. We measure their quality in terms of delay, time-processor efficiency, memory contention (how many requests have to be satisfied by one memory module per simulated step) and simplicity. Further we take into consideration different rules for resolving access conflicts at the modules of the DMM, in particular the c-collision rule motivated by the idea of communicating between processors and modules using an optical crossbar. All simulations are very simple and deterministic (except for the random choice of the hash functions). In particular, we present the first “deterministic” time-processor optimal simulations with delay O(log n), both on Arbitrary DMMs and 2-collision DMMs. (These models are defined in the paper. ) The central idea for the latter simulation also yields a simple “deterministic” simulation of an n-processor PRAM on an n-processor 3-collision DMM with delay bounded by O(log log n) with high probability. For the time analysis of the simulations we utilize a new combinatorial lemma, which may be of independent interest. The lemma concerns events defined by properties of the color classes in random colorings of finite sets. Such events are not independent; the lemma shows that in an important special ● Supported in part by DFG-Forschergruppe “Effiziente Nutzung messiv paralleled Systeme, Tedprojekt 4“, by the Esprit Basic Research Action Nr. 7141 (ALCOM II), and by the Volkswagen Foundation Permission to copy without fee all or part of this material is granted provided that the copies are not made or distributed for diract commercial advantage, the ACM copyright notice and the titla of tha publication and its date appear, and notice is given that copying is by permission of the Association for Computing Machinery. To copy otherwise, or to republish, requires a fee and/or specific permission. ACM-SPAA’93-6/93 /Velen,Germany. @ 1993 ACM O-89791-599-2/~3/0006/01 10...

Exact lower time bounds for computing Boolean functions on CREW PRAMs

1.50 case such events are “negatively correlated”, and thus, for the pupose of upper bounds on certain probabilities, may be treated as if independent.

A comparison of two lower-bound methods for communication complexity

The time complexity of Boolean functions on abstract concurrent-read exclusive-write parallel random access machines (CREW PRAMs) is considered. We improve results of Cook, Dwork, and Reischuk (SIAM J. Comput.15 (1986), 87-97), and extend work of Kutylowski (SIAM J. Comput.20 (1991), 824-833), who proved a lower time bound for the OR function on such machines that equals the upper bound. We provide a general means for obtaining exact (i.e., correct up to an additive constant) lower bounds, which works for many Boolean functions, in particular all symmetric functions. The new approach is based on the fact that Boolean functions can be represented as polynomials with integer coefficients and that the degree of such a polynomial can be taken as a complexity measure. For some functions, e.g., AND and PARITY, the exact time bound also holds for nondeterministic machines. For probabilistic machines, we obtain exact lower time bounds for PARITY in the unbounded error model and, utilizing results by Szegedy (Ph.D. dissertation, University of Chicago, 1989), prove a general lower bound valid for all Boolean functions in the bounded error model. We further show that the (bounded error) probabilistic time complexity of Boolean functions on CREW PRAMs differs at most by a constant factor from the deterministic time complexity. We also obtain exact bounds for machines that allow a few processors to try to write to the same cell simultaneously. These bounds are stronger than those which follow automatically from the exclusive-write bounds. No tight bounds for this model were known before.