Robustness of PSPACE-complete sets

Robustness of PSPACE-complete sets A. Pavan a,1 and Fengming Wang b,1 a Department of Computer Science, Iowa State University. pavan@cs.iastate.edu b Department of Computer Science, Rutgers University. fengming@cs.rutgers.edu Abstract We study the robustness of complete languages in PSPACE and prove that they are robust against P-selective sparse sets. Earlier similar results are known for EXPcomplete sets [3] and NP-complete sets [7]. Key words: Computational Complexity, Complete Sets, Robustness, P-selective Sets, PSPACE. 1 Introduction This paper studies the robustness of complete sets which was initiated by Schöning [8]. Informally, a complete set is robust if it remains complete/hard even after we remove a small amount of information from it. More formally, if L is complete for a complexity class C, we say L is robust against a set S if L S is remains complete/hard for C. Several results are known regarding the robustness of complete sets for classes such as NP and EXP. Since many-one complete sets for EXP are complete via one-to-one and length-increasing reductions [2], it easily follows that they are robust against every sparse set in P. Buhrman, Hoene, Torenvliet [3] showed that many-one complete sets are also robust against sparse P-selective sets. They extended this result to show that 2-tt complete sets for EXP are also robust against sparse P-selective sets. Regarding non-sparse sets, Buhrman and Torenvliet [4] showed that if L is many-one complete for EXP, and S is a set in P with subexponential density, then L S is Turing complete for EXP. 1 This research was supported in part by NSF grant 0430807. Preprint submitted to Elsevier Science 17 July 2008

Recently Glaßer et al. [7] showed that many-one complete sets for NP are also robust against sparse P-selective sets. Several negative results are also known regarding robustness of complete sets. Tang, Fu, and Liu [10] constructed a sparse set S such that for every manyone complete language L for EXP, L S fails to be p m-complete. Buhrman, Hoene, and Torenvliet [3] extended this result to the case of bounded truthtable complete sets for EXP. Glaßer et al. [7] showed similar results for NP. Thus the question of whether a complete set is robust against a sparse set or not crucially depends on the complexity of the sparse set. Buhrman and Torenvliet [5] survey these results. All known results regarding the robustness of complete sets involve the classes EXP and NP. Since NP PSPACE EXP, it is natural to study the robustness properties of PSPACE-complete sets. Do they have the properties of robustness similar to NP and EXP? In this paper we answer this question and show that many-one complete sets for PSPACE are also robust against sparse P-selective sets. Thus our main theorem builds a bridge between two previous results [7] and [3]. 2 Preliminaries Denote the length of a string x as x and the cardinality of a set S as S. The density of a set S is the function d(n) = Σ n S. If d(n) is bounded by a polynomial, we say that S is sparse. We fix a polynomial-time computable injective mapping from any n-tuple x 1, x 2,, x n to a single string. Given a language L and a string x, L(x) = 1 if x L, else L(x) = 0. A language L is P-selective [9], if there exists a polynomial-time Turing machine M such that for any strings x and y, the following conditions hold: M(x, y) {x, y}, and if {x, y} L, then M(x, y) L. We use the following well known result regarding P-selective sets. Lemma 1 [11] Let L be a P-selective language, and S be a finite set. There is a polynomial-time algorithm that orders S according to membership in S. I.e., the algorithm computes strings x 1, x 2,, x m such that {x 1, x 2, x m } = S, and L(x 1 ) L(x 2 ) L(x m ). 2

3 Main Theorem Cai and Furst [6], building on the work of Barrington [1], gave an elegant characterization for PSPACE. Denote the permutation group over five distinct elements as S 5. For each language L PSPACE there exists a polynomial p and a polynomial-time computable function f : Σ Σ S 5 such that x, x L f(x, 1 p( x ) ) f(x, 1 p( x ) 1) f(x, 0 p( x ) ) = I 5 where denotes composition of permutations, and I 5 is the identity permutation. We use this characterization of PSPACE. A set S is non-trivial, if both S and S have at least one element. Note that if a set S is trivial, it is easy to construct a set A in P such that A does not many reduce to S. Thus we focus on non-trivial sets. Theorem 2 Let L be a p m-complete set for PSPACE and let S be a P- selective sparse set. If L S is non-trivial, then L S is p m-hard for PSPACE. Proof. Let p and f correspond to L in the above characterization. Define the following set T : T = { x, y, π y = p( x ), π S 5 and f(x, 1 p( x ) ) f(x, y) = π} Clearly T belongs to PSPACE and there is a trivial p m-reduction from L to T which maps x to x, 0 p( x ), I 5, thus T is p m-complete for PSPACE. Let h denote the p m-reduction from T to L, and let h be computable in time q(n). Let S be a sparse P-selective set that has at most l(n) elements at length n. We now present an algorithm which witnesses the reduction from L to L S. Fix two strings y 1, y 2 such that y 1 L S and y 2 L S. Since L S is non-trivial, such strings exist. On input x, the algorithm maintains a list, denoted List, and ensures that for every y List, y belongs to L if and only if x belongs to L. We also ensure that the algorithm increments the size of the list during each iteration. Since S is sparse, after polynomially many iterations List will contain an element y that does not belong to S. At this stage, the algorithm will output y. We now give details. (1) Input x. (2) Set left = 0 p( x ), and List = {h( x, left, I 5 )}. (3) Find π such that h( x, 1 p( x ), π ) List. If f(x, 1 p( x ) ) = π, return y 1, else return y 2. If there is no such π, GOTO next step. 3

(4) Using binary search, find a string z such that left < z < 1 p( x ) and π, h( x, z, π ) List, and π, h( x, z + 1, π ) / List. Recall that there is no π for which h( x, 1 p( x ), π ) List, and there is a π such that h( x, left, π, ) List. Thus a string z with above properties must exist. (5) Let π be a permutation for which h( x, z, π ) List. Compute π = π f(x, z) 1 and w = h( x, z + 1, π ). Add w to List. (6) If List l(q( x, 0 p( x ), I 5 )), set left = z, and GOTO Step 3. (7) By Lemma 1, there is a polynomial-time algorithm that orders List. Output the first string in this order. We claim that the above reduction is correct. Trivially each step of the reduction, including the binary search, can be done in polynomial-time. Observe that when the size of List reaches l(q( x, 0 p( x ), I 5 )) + 1, the reduction stops. Also observe that during each iteration of the algorithm, the size of List increases by one. Thus the reduction is polynomial-time computable. Claim 1 For every string y List, x L if and only if y L. Proof. We prove this by induction. Initially the algorithm places h( x, 0 p( x ), I 5 ) into List. Recall that x L if and only if x, 0 p( x ), I 5 T. Since h is a reduction from T to L, x L if and only if h( x, 0 p( x ), I 5 ) L. Thus the claim holds initially. Assume that the claim holds before the start of an iteration. During an iteration, the algorithm finds a string z and a permutation π such that h( x, z, π ) List. By the induction hypothesis, h( x, z, π ) L if and only if x L. Thus, since h is a reduction from T to L, x, z, π T if and only if x L. Thus x L f(x, 1 p( x ) ) f(x, z + 1) f(x, z) = π f(x, 1 p( x ) ) f(x, z + 1) = π f(x, z) 1 = π x, z + 1, π T h( x, z + 1, π ) L. Since the reduction places h( x, z + 1, π ) into the list, the previous claim holds after this iteration of the algorithm. Thus for every string y List, x belongs to L if and only if y belongs to L. 4

Claim 2 The above reduction is correct Proof. The algorithm outputs a string either in Step 3 or in Step 7. First consider the case when it outputs a string in Step 3. In this case, there is a π such that h( x, 1 p( x ), π ) List. Thus, by the previous claim, x L if and only if h( x, 1 p( x ), π ) List. Thus x L if and only if x, 1 p( x ), π ) T. Thus x L if and only if f(x, 1 p( x ) ) = π. If f(x, 1 p( x ) ) = π, then the reduction outputs y 1, else it outputs y 2. Since y 1 L S, and y 2 L S, the reduction is correct. Assume that the reduction outputs a string in Step 7. Since S has at most l(q( x, 0 p( x ), I 5 )) strings of length q( x, 0 p( x ), I 5 ) and the cardinality of List is l(q( x, 0 p( x ), I 5 )) + 1, there is a string in List that is not in S. Thus when we order List using Lemma 1, the first string in the order does not belong to S. Thus the string output by the reduction does not belong to S. Also, by the previous claim, for every string y in List, x L if and only if y L. Thus the string output by the reduction belongs to L S if and only if x L. Thus L S is many-one hard for PSPACE. Observe that if a sparse set S is in P, then L S is in PSPACE. Corollary 3 Let L be an p m-complete set for PSPACE and let S be a sparse set in P. If L S is non-trivial, then L S remains p m-complete for PSPACE. References [1] D. Barrington. Bounded-width polynomial-size branching programs recognize exactly those languages in NC 1. Journal of Computer and System Sciences, 38(1):150 164, 1989. [2] L. Berman. On the structure of complete sets: Almost everywhere complexity and infinitely often speedup. In IEEE Conference on Foundations of Computer Science, pages 76 80, 1976. [3] H. Buhrman, A. Hoene, and L. Torenvliet. Splittings, robustness, and structure of complete sets. SIAM J. Comput., 27(3):637 653, 1998. [4] H. Buhrman and L. Torenvliet. Separating complexity classes using structural properties. In IEEE Conference on Computational Complexity, pages 130 138, 2004. [5] H. Buhrman and L. Torenvliet. A Post s program for complexity theory. Bulletin of the EATCS, 85:41 51, 2005. 5

[6] J. Cai and M. Furst. PSPACE survives constant-width bottlenecks. Int. J. Found. Comput. Sci., 2(1):67 76, 1991. [7] C. Glaßer, A. Pavan, A. Selman, and S. Sengupta. Properties of NP-complete sets. In IEEE Conference on Computational Complexity, pages 184 197, 2004. [8] U. Schöning. Complete sets and closeness to complexity classes. Mathematical Systems Theory, 19(1):29 41, 1986. [9] A. Selman. P-selective sets, tally languages, and the behavior of polynomial time reducibilities on NP. Mathematical Systems Theory, 13:55 65, 1979. [10] S. Tang, B. Fu, and T. Liu. Exponential-time and subexponential-time sets. Theor. Comput. Sci., 115(2):371 381, 1993. [11] S. Toda. On polynomial-time truth-table reducibility of intractable sets to P- selective sets. Mathematical Systems Theory, 24(2):68 82, 1991. 6