Martin Hühne

On the power of several queues

Abstract We present almost matching upper and lower time bounds for the simulation of Turing machines with many queues, tapes, or stacks on Turing machines with few queues. In particular, the power of two queues in comparison with other storage types is clarified. We show that t ( n )-time-bounded multistorage Turing machines can be simulated in time O( t ( n ) 1 + 1/ k ) on k -queue machines. Every online simulation of k + 1 queues (or of two tapes) on k queues requires time Ω( t ( n ) 1 + 1/ k /polylog t ( n )). The lower bounds are based on Kolmogorov complexity.

A dictionary implementation based on dynamic perfect hashing

We describe experimental results on an implementation of a dynamic dictionary. The basis of our implementation is “dynamic perfect hashing” as described by Dietzfelbinger et al. (SIAM J. Computing 23, 1994, pp. 738--761), an extension of the storage scheme proposed by Fredman et al. (J. ACM 31, 1984, pp. 538--544). At the top level, a hash function is used to partition the keys to be stored into several sets. On the second level, there is a perfect hash function for each of these sets. This technique guarantees O(1) worst-case time for lookup and expected O(1) amortized time for insertion and deletion, while only linear space is required. We study the practical performance of dynamic perfect hashing and describe improvements of the basic scheme. The focus is on the choice of the hash function (both for integer and string keys), on the efficiency of rehashing, on the handling of small buckets, and on the space requirements of the implementation.

Matching upper and lower bounds for simulations of several linear tapes on one multidimensional tape

Abstract. We prove an O(t(n)d(t(n))½ / log t(n)) time bound for the sim-ulation of t(n) steps of a Turing machine using several one-dimensional work tapes on a Turing machine using one d-dimensional work tape,

ON THE AVERAGE CASE CIRCUIT DELAY OF DISJUNCTION

d \ge 2

Matching Upper and Lower Bounds for Simulation of Several Tapes on One Multidimensional Tape

. We prove a matching lower bound which holds for the problem of recognizing languages on machines with a separate one-way input tape.

Linear speed-up does not hold on Turing machines with tree storages

For circuits the expected delay is a suitable measure for the average case time complexity. In this paper, new upper and lower bounds on the expected delay of circuits for disjunction and conjunction are derived. The circuits presented yield asymptotically optimal expected delay for a wide class of distributions on the inputs even when the parameters of the distribution are not known in advance.

An Introduction to Semidefinite Programming and its Applications to Approximation Algorithms

We prove a \(\Theta (t(n)\sqrt[d]{{t(n)}}/\log i(n))\) bound for the simulation of t(n) steps of a Turing machine using several one-dimensional work tapes on a Turing machine using one d-dimensional work tape, d ≥ 2. The lower bound holds for the problem of recognizing languages on machines with a separate one-way input tape.

Semidefinite Programming and Its Applications to Approximation Algorithms

Abstract It is well known that on Turing machines using tapes as storage it is possible to speed up the computation time by any constant factor. Using Kolmogorov complexity we show that on Turing machines using tree storages this effect does not occur.

The hedge: An efficient storage device for Turing machines with one head

Known examples for problems which can be treated in this way include the Knapsack problem. Given n objects with size cj and value tj , we want to ll a knapsack such that its value is maximized. This is an NP-hard problem, but if we are allowed to take fractional parts of the objects, then we can solve the problem in polynomial time, using a greedy algorithm. The greedy solution provides us with an upper bound for the original Knapsack problem.

Concrete complexity theory - studies of the impact of the capabilities of the storage device on the efficiency of computations

In this chapter surveys recent achievements in constructing approximation algorithms based on semidefinite programming. A generalization of linear programming, semidefinite programming had been studied before for some time and in various contexts. However, only a few years ago Goemans and Williamson showed how to make use of it in order to provide good approximation algorithms for several optimization problems.