1. Space Hierarchy Results for Randomized Models
Thank you. I am Jeff Kinne, presenting joint research with Dieter van Melkebeek
titled Space Hierarchy Results for Randomized Models.
Jeff Kinne
Dieter van Melkebeek
University of Wisconsin-Madison

2. Time Hierarchy Theorems
Does allowing more resources yield strictly more computational power? …
We develop space hierarchy results building on techniques that have been developed in the time-bounded setting. We first review time hierarchy theorems.
The question we aim to answer is whether allowing a machine more resources results in strictly more computational power. Intuition tells us the answer should be yes.
For example consider the sets of languages computable by randomized machines in time n, n^2, n^3 and so on. Are these classes all distinct, or do they collapse to some point?
For randomized machines, this is a major open question – for all we know, it could be that polynomial time, or even nearly exponential time, randomized machines are no more powerful than linear time randomized machines. n3 n2 n
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

3. Time Hierarchy Theorems
Deterministic Machines
Diagonalization [HS65]
Nondeterministic Machines
Not known to be closed under complement
Translation Arguments, Delayed Diagonalization, … [C73, SFM78, Ž83]
Randomized Machines
No Computable Enumeration of Machines
Good Hierarchy Still Open
Additional Techniques [B02, FS04, MP07, …] ⇨ Bounded-Error Randomized Machines with Advice
Very good time hierarchy theorems for deterministic machines were proved early on using diagonalization.
The proofs for deterministic machines rely on the ability to perform complementation with small overhead.
We do not know how to accomplish this for nondeterministic machines.
Additional techniques have been developed to overcome this difficulty, including translation arguments and delayed diagonalization, so that we have a good time hierarchy for nondeterministic machines.
Now consider bounded-error randomized machines, that is, randomized machines that satisfy the condition that on every input, the probability of acceptance is bounded away from ½ (say at most 1/3 or greater than 2/3).
All of the aforementioned techniques rely on the existence of a computable enumeration of all machines. We can enumerate all randomized machines, but this list would contain machines which break the promise of bounded error. A simple exercise in computability theory shows that there is no computable enumeration of bounded-error randomized machines, and thus traditional techniques for proving hierarchy theorems fail, and whether there are good hierarchy theorems for bounded-error machines is a major open question.
A recent line of research has employed new techniques to show that these problems can be overcome by giving the randomized machines a single bit of advice. This is a standard notion, where each machine is given an additional input which is fixed for each input length to assist in the computation, giving a non-uniform model of computation. The constructions guarantee that the diagonalizing machine with the correct advice bits differs from all randomized machines using slightly less time.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

4. Time Hierarchy Theorems: Randomized Machines
Two-sided error machines
TIME(poly)/1 ⊈ TIME(nc)/1 [FS04, GST04, MP07]
Two-sided error machines
TIME(poly)/1 ⊈ TIME(nc)/O(log n) [FS04, GST04, MP07]
One-sided error machines
TIME(poly)/1 ⊈ TIME(nc)/O(log1/c n), for all c >1 [FST05, MP07]
Zero-sided error machines
TIME(poly)/1 ⊈ TIME(nc)/O(1) [MP07]
For two-sided error machines, these techniques show that there is a two-sided error machine using polynomial time and one bit of advice which differs from all two-sided error machines which use a fixed polynomial amount of time and one bit of advice. This implies that if we allow one bit of advice, the classes given in the picture at the beginning are distinct.
In fact, the techniques allow the smaller time machines a large amount of advice, while the diagonalizing machine still only requires one bit of advice.
A similar result is known for one-sided error machines, which is slightly weaker in that the smaller-time machines can be allowed slightly less advice.
For zero-sided error machines, the best known result only allows a constant amount of advice for the smaller-time machines.
Now let us consider the status of hierarchy theorems in the space-bounded setting.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

5. Space Hierarchy Theorems
Deterministic Machines
Diagonalization ✓
Tight: SPACE(s) ⊈ SPACE(s), for any s = (s)
Models with Computable Enumeration of Machines
Translation Arguments, Delayed Diagonalization, … ✓
Bounded-Error Randomized Machines?
As in the time-bounded setting, simple diagonalization suffices to prove very good hierarchy theorems for deterministic machines. In fact, the space-hierarchy theorems for deterministic machines are as tight as possible – any super-constant gap in space suffices for diagonalization. This is still an open question for time-hierarchies on deterministic machines – where a super-logarithmic gap in time is needed for the best-known results.
As in the time-bounded setting, translation arguments and delayed diagonalization suffice to prove very good space-hierarchy theorems for any form of computation where there exists a computable enumeration of all valid machines.
But what is the status for bounded-error randomized machines?
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

6. Space Hierarchy Theorems – Randomized Machines
Randomized space s ⊆ Deterministic space s2 [S70,J81,BCP83]
Randomized space s ⊈ Randomized space s, for s = (s2)
Randomized space s ⊈ Randomized space s, for s = (s1+), any  > 0 [KV87]
Would like space s ⊈ space s for any s = (s)
Recall that no matter which notion of bounded-error used (two, one, or zero-sided), bounded-error randomized machines can be simulated by deterministic machines with only a quadratic blowup in space. Together with the tight space hierarchy theorem for deterministic machines, this already gives a space-hierarchy theorem for randomized machines where a randomized machine using slightly more than space s^2 can diagonalize against all randomized machines which use space s.
In fact a translation argument shows that any polynomial gap in space suffices.
DON’T DO FOR THIS TALK: The exponent is decreased from 2 to 1+delta for any delta by assuming the separation with exponent 1+delta fails and composing this assumption multiple times until the result with exponent 2 is violated. END DON’T DO.
This result is much better than what is known in the time-bounded setting for randomized machines, where close to an exponential gap in time is required for the best-known results.
Even so, this space-hierarchy theorem is not as tight as possible. By using additional techniques and one bit of advice, we prove space hierarchy theorems that are as tight as possible.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

7. Our Results – Randomized Machines
Two-sided error machines
SPACE(s)/1 ⊈ SPACE(log n)/O(log n), for any s = (log n)
One-sided error machines
Zero-sided error machines
Logarithmic space represents space efficiency just as polynomial time represents time efficiency.
We state our results for the logarithmic space setting for concreteness and clarity of presentation. We state generalizations later.
For two-sided error machines, we demonstrate a hierarchy with a tight separation in space where the diagonalizing machine uses one bit of advice and differs from all two-sided error machines using logarithmic space and a logarithmic number of advice bits.
For one-sided error machines, we prove a result with the same parameters.
For zero-sided error machines, we prove a result that again has the same parameters.
We point out that in some respects our results match the corresponding results from the time-bounded setting, while in other respects they are stronger. First, our results for one-sided and zero-sided error machines can handle a larger amount of advice than the corresponding results in the time-bounded setting. Second, our results remain tight for a wide range of space bounds, while this is not true in the time-bounded setting. We will come back to this point later.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

8. Two-sided error machines: first attempt
Enumeration of all randomized machines
Diagonalization M1 M2 M3 … N x1
M1(x1)
¬ M1(x1)
For the bulk of the rest of this talk, we present the main ideas of the construction which proves our result for two-sided error machines.
Let us first see why simple diagonalization fails.
Diagonalization begins with an enumeration of all machines of interest. As stated earlier, there is no computable enumeration of exactly all two-sided error randomized machines, but we can try to work with an enumeration of all randomized machines, which includes those that have bounded error as well as those that do not.
We wish to construct a machine N which uses small space and computes a language different than that computed by any two-sided error small space machine in the list. N allocates a distinct input for each machine in the list, and on a given input simulates the corresponding machine and flips the result. N only performs the simulation as long as it uses small space.
N does compute a language different than any two-sided error small space machine. But does N have bounded error?
Recall that the enumeration of machines contains those which do not have bounded error. For example, suppose machine M3 does not have bounded error on input x3. Then by performing the simulation of M3, N does not have bounded error on input x3, and is not a valid two-sided error machine, and does not witness a hierarchy theorem.
We therefore need other ingredients to derive our hierarchy results. x2
M2(x2)
¬ M2(x2) x3
M3(x3)
¬ M3(x3) … …
Pr[N(x3) = 1] = ½
Pr[M3(x3) = 1] = ½
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

9. Two-sided error machines: high level approach
“Hard” Language L Mi N
Advice
Advice
Input Length n xa x xa x
¬ Mi(x)
¬ Mi(xa)/a
n +1
We now give our high level approach, which has also been used in the time-bounded setting.
N is the diagonalizing machine we will construct and we consider one particular machine Mi we wish to differ from. We need to ensure that N has two-sided error and uses small space even if Mi does not.
With simple diagonalization, we allocated an input x on which to attempt to differ from Mi on. We have seen we cannot do this directly, but keep the goal in mind.
We make use of a hard language L, which if given as an oracle, would allow N to complement the behavior of Mi while always maintaining bounded error. We are working with logarithmic space randomized computations, which can be decided in deterministic polynomial time, so L could be a P-complete language. We will in fact use a P-complete language for L, and specify it later.
If N could compute L on these instances, we would be done. But we don’t know how to directly compute these instances with small space randomized machines.
We employ a delayed computation and simulation scheme that forces Mi into assisting with the computation of L. The scheme allows us to diagonalize against Mi over an interval of input lengths – meaning we will gaurantee that either Mi is not a small space two-sided error machine or there is at least one input within the range of input lengths on which N differs from Mi. We start by looking at large padded inputs, large enough so that the space required to solve L by brute force is logarithmic in the padded length, and have N perform this delayed computation.
Suppose for the moment that Mi is a valid small space two-sided error machine. If Mi is to compute the same language as N, it must also perform the delayed computation of L on these padded inputs. We use this fact to copy the delayed computation down to padded inputs of one smaller size. That is, on padded inputs of one smaller length, N simulates Mi on padded inputs of the larger length. Assuming Mi computes the same language as N on the larger padded inputs, now N performs the delayed computation on padded inputs of one smaller length.
If we assume Mi computes the same language as N at this length, we again conclude that it must also perform the delayed computation of L on these padded inputs. On each smaller padded input, we have N simulate Mi on the larger padded input, and we reach the conclusion that if Mi computes the same language as N on all inputs, N computes the hard language on the instances we were interested in, and it can therefore complement Mi on input x. Further, N uses small space by clocking the space usage of Mi and halting if the simulation uses too much space.
But remember that we have no gaurantee on the behavior of Mi. If Mi does not have bounded error on some input, N does not have bounded error on a padded input of one smaller length.
But if Mi is not a valid two-sided error machine, then we do not need to worry about it in the first place. We give N one bit of advice indicating if Mi correctly performs the initial delayed computation. If the advice bit is 1, then everything is as we described it before. If the advice bit is 0, then either we have already differed from Mi on these padded inputs, or Mi is not a valid small space two-sided error machine. In either case, N does not need to worry about Mi any more. For each input length, we give one bit of advice indicating whether Mi on the next larger input length correctly performs the delayed computation. We conclude that N with the correct advice bits is a small space two-sided error machine that differs from Mi.
But by giving N advice, it can trivially compute languages different than any machine that does not have advice, so for a fair hierarchy, we should give Mi advice as well. In fact we will be able to give Mi a large amount of advice. How does this effect the construction?
We want to make sure that N with the correct advice bits computes a language different than Mi no matter which advice bits Mi is given. The green arrows signify that if Mi performs a delayed computation of the hard language then N should copy down this behavior to padded inputs of one smaller length. Now Mi computes the same language as N if there is at least one advice string causing it to do so, meaning that N should copy down the delayed computation of the hard language to padded inputs of one smaller length if there is at least one advice string causing Mi correctly perform the delayed computation. We call a procedure accomplishing this task a recovery procedure.
If we can give a recovery procedure for the hard language, the construction remains valid, and we will reach the conclusion that if there exists a sequence of advice strings causing Mi to compute the same language as N on all padded inputs, then N computes the hard language L on the instances of interest. We then ensure that N computes a language different than Mi at length n for all advice strings by allocating a separate input x_a for each possible advice string a that Mi could receive at length n, and complementing Mi on each. … … y y …
N(y)=L(y) … … …
Recovery Procedure
0ℓ-1y
0ℓ-1y
N(0ℓ-1y)=Mi(0ℓy)
0ℓy
0ℓy
N(0ℓy)=L(y)
What if Pr[Mi(0ℓy) = 1] = ½ ?
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

10. Recovery Procedure for L
Input: y, list of randomized machines
Output: L(y), using small space, with 2-sided error
Pre-condition: at least one machine in list computes L on instances of length |y|, using small space, with 2-sided error
If we ignore the padding involved, a recovery procedure should accomplish the following task.
We are given a string y for which we want to determine membership in the hard language, and we have a list of randomized machines - namely Mi with all possible advice strings.
We hope to compute L(y), using small space, with 2-sided error.
Remember that we only need to accomplish this if there is some advice string causing Mi to correctly compute L. So we can take as a pre-condition that at least one of the randomized machines in the list of machines computes L on the instances of interest, using small space, with 2-sided error.
This task is similar to the problem of program checking, where instead of a list of randomized machines, there is a single fixed oracle to test for correctness. Our task is complicated by the fact we are testing randomized procedures which may behave arbitrarily. Although at least one machine correctly computes the hard language, the remaining machines may not even be valid two-sided error machines. Dealing with this is the main hurdle in designing the recovery procedure.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

11. Hard Language L
L = Computation Tableau Language = {‹M,x,t,j› | M deterministic machine, after t time steps on input x, j-th bit of configuration is 1}
Can reduce behavior of two-sided error space-bounded machines to L
By P-completeness of L and BPL ⊆ P
Space-efficient Recovery Procedure for L
All that remains is to specify the hard-language and give a space-efficient recovery procedure for it.
The language we use we call the Computation Tableau Language, which is an encoding of the computation tableau of deterministic Turing machines. An instance of the language corresponds to a deterministic machine M, an input x for that machine, a time-step t at which we look at the internal configuration of the machine, and an index j into the configuration at time t. The instance is in the language if the j-th bit of the configuration at time t is equal to 1.
The language must be “hard” in that we can reduce the behavior of 2-sided error small space machines to L. This follows by the fact the language is P-complete and small space randomized machines can be decided in deterministic polynomial time.
We also need a space-efficient recovery procedure for the language.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

12. Recovery Procedure Input: ‹M,x,t,j›, {P1, P2, P3, …}
Can use P to decide?
Can reduce error of P?
Pr[P(‹M,x,t’,j’›) = 1] far from ½ for all t’, j’
Pass test ⇨ can reduce error of P
Local Consistency
Check value claimed by P on ‹M,x,t’,j’› against values of previous row
The recovery procedure takes as input a potential instance of the hard language and a list of randomized machines.
First remember that the recovery procedure must use small space. As the deterministic machine M may use large space, we cannot simply simulate M until it reaches time t.
Instead we will look at each randomized machine, and perform a series of tests to determine if that machine is a small space two-sided error machine which computes the hard language on this instance. We take the first machine to pass the tests and simulate it to determine our output.
Consider a machine P. The fact that P may not have bounded error makes testing problematic. We begin with a series of tests to ensure that P’s probability of acceptance on each instance of the tableau is either exponentially close to 0 or exponentially close to 1. The tests have the property that if P passes the tests with non-negligible probability, then we can use majority voting to reduce the error to exponentially small. This means that we can essentially treat P as a deterministic machine.
If P passes the first series of tests, we check that the values claimed by P on each tableau bit are locally consistent. Each bit of the tableau depends on a constant number of bits from the previous row, so we can check that these bits are consistent without having to use too much space.
If P passes all local consistency checks we output the same value as P.
The two different series of tests together guarantee that any machine passing testing with non-negligible probability computes the correct result with probability exponentially close to 1. Then the procedure can only fail with probability greater than 1/3 if every machine in the list fails the testing with very high probability. But we are guaranteed there is a machine in the list that correctly computes the hard language with bounded error, and this machine will pass testing with high probability. We conclude that the recovery procedure fails with probability less than 1/3.
This concludes the outline of our construction for two-sided error machines. PAUSE
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

13. One- and Zero-sided Error Machines
Same high level approach
Hard Language “L” ⇨ NL-complete language similar to st-connectivity
Zero-error recovery procedure for L based on inductive counting [I88, S88]
Mimic proof that NL=coNL, replacing nondeterministic guesses with queries to randomized machine
For one and zero-sided error machines, we use the same high level approach, with the main differences being the hard language used and the recovery procedure for that language.
For the hard language L, we use an NL-complete language similar to st-connectivity, and give a zero-error recovery procedure for this language that is based on inductive counting.
OPTIONAL: The main idea of the recovery procedure is to mimic the proof that NL=coNL to determine connectivity and replace nondeterministic guesses with queries to the randomized machines we are testing. Because the algorithm is able to discover incorrect non-deterministic guesses, this leads to a zero-error recovery procedure.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

14. Recap Two-sided error machines One-sided error machines
SPACE(s)/1 ⊈ SPACE(s)/s, for any s = (s), typical s from log(n) to n
One-sided error machines
Zero-sided error machines
Two-sided error machines
SPACE(s)/1 ⊈ SPACE(s)/s, for any s = (s), s=O(log n)
One-sided error machines
Zero-sided error machines
Two-sided error machines
SPACE(s)/1 ⊈ SPACE(log n)/O(log n), for any s = (log n)
One-sided error machines
Zero-sided error machines
To recap the results we have discussed, we show the following for each of the types of bounded-error machines.
A hierarchy with a tight separation in space where the diagonalizing machine uses one bit of advice and differs from all two-sided error machines using logarithmic space and a logarithmic number of advice bits.
If we set s=O(log n), these can be re-written as follows.
In fact, our results generalize to higher space bounds and remain tight – that is, any super-constant gap in space suffices – for typical s up to linear.
This fact is another strengthening of our results over the corresponding results that are known in the time-bounded setting, which are no longer as tight for any super-polynomial time bounds.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

15. Other Results Any Reasonable Semantic Model
SPACE(s)/1 ⊈ SPACE(log n)/O(1), for any s = (log n)
If efficient deterministic simulation exists
SPACE(s)/1 ⊈ SPACE(s)/O(1), for typical s from log(n) to polynomial, any s = (s)
We also adapt and analyze a different construction that has been given in the time-bounded setting that applies to a wide class of machine types termed reasonable semantic models. The notion includes just about any form of computation we are used to reasoning about, such as randomized machines, quantum machines, arthur-merlin games, and so on.
We derive a result that matches what is known in the time-bounded setting, that within any reasonable semantic model, a machine with slightly super-logarithmic space and one bit of advice can diagonalize against all machines using logarithmic space and a constant number of advice bits.
For models of computation that can be simulated deterministically with only a polynomial blowup in space, such as unambiguous machines and randomized machines, we show that the result remains tight for typical space bounds up to polynomial.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models

16. Merci
Thank you
Thank you.
STACS 2008, Feb 21-23
Jeff Kinne and Dieter van Melkebeek Space Hierarchy Results for Randomized Models