Noam Nisan

Hardness vs randomness

We present a simple new construction of a pseudorandom bit generator. It stretches a short string of truly random bits into a long string that looks random to any algorithm from a complexity class C (e.g., P, NC, PSPACE, ...) using an arbitrary function that is hard for C. This construction reveals an equivalence between the problem of proving lower bounds and the problem of generating good pseudorandom sequences. Our construction has many consequences. The most direct one is that efficient deterministic simulation of randomized algorithms is possible under much weaker assumptions than previously known. The efficiency of the simulations depends on the strength of the assumptions, and may achieve P = BPP. We believe that our results are very strong evidence that the gap between randomized and deterministic complexity is not large. Using the known lower bounds for constant depth circuits, our construction yields an unconditionally proven pseudorandom generator for constant depth circuits. As an application of this generator we characterize the power of NP with a random oracle.

Algebraic methods for interactive proof systems

A new algebraic technique for the construction of interactive proof systems is presented. Our technique is used to prove that every language in the polynomial-time hierarchy has an interactive proof system. This technique played a pivotal role in the recent proofs that IP = PSPACE [28] and that MIP = NEXP [4].

Randomness is Linear in Space

We show that any randomized algorithm that runs in spaceSand timeTand uses poly(S) random bits can be simulated using onlyO(S) random bits in spaceSand timeT+poly(S). A deterministic simulation in spaceSfollows. Of independent interest is our main technical tool: a procedure which extracts randomness from a defective random source using a small additional number of truly random bits.

Pseudorandom generators for space-bounded computations

Pseudorandom generators are constructed which convertO(SlogR) truly random bits toR bits that appear random to any algorithm that runs inSPACE(S). In particular, any randomized polynomial time algorithm that runs in spaceS can be simulated using onlyO(Slogn) random bits. An application of these generators is an explicit construction of universal traversal sequences (for arbitrary graphs) of lengthnO(logn).

Combinatorial auctions with decreasing marginal utilities

In most of microeconomic theory, consumers are assumed to exhibit decreasing marginal utilities. This paper considers combinatorial auctions among such buyers. The valuations of such buyers are placed within a hierarchy of valuations that exhibit no complementarities, a hierarchy that includes also OR and XOR combinations of singleton valuations, and valuations satisfying the gross substitutes property. While we show that the allocation problem among valuations with decreasing marginal utilities is NP-hard, we present an efficient greedy 2-approximation algorithm for this case. No such approximation algorithm exists in a setting allowing for complementarities. Some results about strategic aspects of combinatorial auctions among players with decreasing marginal utilities are also presented.

Computationally feasible VCG mechanisms

A major achievement of mechanism design theory is a general method for the construction of truthful mechanisms called VCG (Vickrey, Clarke, Groves). When applying this method to complex problems such as combinatorial auctions, a difficulty arises: VCG mechanisms are required to compute optimal outcomes and are, therefore, computationally infeasible. However, if the optimal outcome is replaced by the results of a sub-optimal algorithm, the resulting mechanism (termed VCG-based) is no longer necessarily truthful. The first part of this paper studies this phenomenon in depth and shows that it is near universal. Specifically, we prove that essentially all reasonable approximations or heuristics for combinatorial auctions as well as a wide class of cost minimization problems yield non-truthful VCG-based mechanisms. We generalize these results for affine maximizers. The second part of this paper proposes a general method for circumventing the above problem. We introduce a modification of VCG-based mechanisms in which the agents are given a chance to improve the output of the underlying algorithm. When the agents behave truthfully, the welfare obtained by the mechanism is at least as good as the one obtained by the algorithm’s output. We provide a strong rationale for truth-telling behavior. Our method satisfies individual rationality as well.

Algorithmic mechanism design (extended abstract)

We consider algorithmic problems in a distributed setting where the participants annot be assumed to follow the algorithm but rather their own self-interest. As such pxticipants, termed agents, are capable of manipulating the algorithm, the algorithm designer should ensure in advance that the agents’ interests are best served by behaving correctly. Following notions from the field of mechanism design, we suggest a framework for studying such algorithms. In this model the algorithmic solution is adorned with payments to the participants and is termed a mechanism. The payments should be carefully chosen a6 to motivate all participants to act as the algorithm designer wishes. We apply the standard tools of mechanism design to algorithmic problems and in particular to the shortest path problem. Our main technical contribution concerns the study of a representative problem, task scheduling, for which the standard tools do not suffice. We present several theorems regarding this problem including an approximation me&anism, lower bounds and a randomized mechanism. We also suggest and motivate extensions to the basic model and prove improved upper bounds in the extended model. Many open problems are suggested as well.

BPP has subexponential time simulations unless EXPTIME has publishable proofs

AbstractWe show thatBPP can be simulated in subexponential time for infinitely many input lengths unless exponential timeℴ collapses to the second level of the polynomial-time hierarchy.ℴ has polynomial-size circuits andℴ has publishable proofs (EXPTIME=MA). We also show thatBPP is contained in subexponential time unless exponential time has publishable proofs for infinitely many input lengths. In addition, we showBPP can be simulated in subexponential time for infinitely many input lengths unless there exist unary languages inMA-P.The proofs are based on the recent characterization of the power of multiprover interactive protocols and on random self-reducibility via low-degree polynomials. They exhibit an interplay between Boolean circuit simulation, interactive proofs and classical complexity classes. An important feature of this proof is that it does not relativize.One of the ingredients of our proof is a lemma that states that ifEXPTIME has polynomial size circuits thenEXPTIME=MA. This extends previous work by Albert Meyer.

On the degree of Boolean functions as real polynomials

Every Boolean function may be represented as a real polynomial. In this paper, we characterize the degree of this polynomial in terms of certain combinatorial properties of the Boolean function.Our first result is a tight lower bound of Ω(logn) on the degree needed to represent any Boolean function that depends onn variables.Our second result states that for every Boolean functionf, the following measures are all polynomially related:o The decision tree complexity off.o The degree of the polynomial representingf.o The smallest degree of a polynomialapproximating f in theLmax norm.

Multiparty protocols, pseudorandom generators for logspace, and time-space trade-offs

Let f(x1, …, xk) be a Boolean function that k parties wish to collaboratively evaluate, where each xi is a bit-string of length n. The ith party knows each input argument except xi; and each party has unlimited computational power. They share a blackboard, viewed by all parties, where they can exchange messages. The objective is to minimize the number of bits written on the board. We prove lower bounds of the form Ω(n · c−k), for the number of bits that need to be exchanged in order to compute some (explicitly given) polynomial time computable functions. Our bounds hold even if the parties only wish to have a 1 % advantage at guessing the value of f on random inputs. The lower bound proofs are based on discrepancy upper bounds for specific functions over “cylinder intersection” sets. These results may be of independent interest. We give several applications of the lower bounds. The first application is a pseudorandom generator for Logspace. We explicitly construct (in polynomial time pseudorandom sequences of length n from a random seed of length exp(c √log n) that no Logspace Turing machine will be able to distinguish from truly random sequences. As a corollary we give an explicit construction of a universal traversal sequence of length exp(exp(c√log n)) for arbitrary undirected graphs on n vertices. We then apply the multiparty protocol lower bounds to derive several new time-space trade-offs. We give a tight time-space trade-off of the form TS =Θ(n2), for general, k-head Turing machines; the bounds hold for a function that can be computed in linear time and constant space by a k + 1-head Turing machine. We also give a new length-width trade-off for oblivious branching programs; in particular, our bound implies new lower bounds on the size of arbitrary branching programs, or on the size of Boolean formulas (over an arbitrary finite base). Using universal hashing, Nisan has recently constructed considerably improved random generators for Logspace, with the implication of shorter explicit universal traversal sequences. The time-space and related trade-off results mentioned above are not affected by this development.