A Critique of Czerwinski’s “Separation of and ”††thanks: Supported in part by NSF grant CCF-2006496.
Abstract
Czerwinski’s paper “Separation of and ” [Cze21] claims to prove that by showing there is no length-increasing polynomial-time reduction from a given -complete set to a given -complete set. However, in this critique, we show that there are fundamental flaws within the paper’s approach and provide a counterexample to one of the paper’s theorems, which makes the proposed proof that insufficient.
1 Introduction
In this critique, we provide a summary and analysis of Czerwinski’s “Separation of \pspace and \exptime” [Cze21]. The paper purportedly proves its main claim that by introducing a novel proof technique with three main theorems: Theorem 1 proposes that any nontrivial property P of the time and space complexity of an arbitrary Turing machine is undecidable, Theorem 2 claims that if sets A and B are both -complete sets, then they are length-increasing one-one reducible to each other, and Theorem 3 argues that there exists an -complete set and a -complete set such that is not length-increasing one-one reducible to . If correct, Czerwinski’s paper would be a major advance in computational complexity theory. In particular, it is well-known that . On the other hand, whether equals remains one of the major open questions in theoretical computer science. Furthermore, if Czerwinski’s paper truly has introduced a novel proof technique to separate and , that could potentially serve as the foundation to establish other new separations.
The approach used in Czerwinski’s paper to show the separation of and is as follows: Use Corollary 2 of Theorem 1 to prove Theorem 3, and then by Theorem 2 and Theorem 3, claim that . We aim to highlight the flaws in each of these theorems as well as present a counterexample to one of the theorems, thus showing that the paper fails to prove its central claim.
2 Preliminaries
In this section, we present readers with many standard concepts in complexity theory, as well as frequently used notations in Czerwinski’s paper. Interested readers can find equivalent definitions of the concepts in most modern textbooks on complexity [HO02, AB09, Sip13].
Let and let . Given a string , let denote the length of . We will let denote the empty string. For any Turing machine (TM) , let be the language accepted by .
We also introduce some notations that Czerwinski uses throughout the paper. For a single-tape deterministic Turing machine on input , let be the tape space used by on input and let be the time used by on input . Lastly, a property is a set of Turing machines. A Turing machine is said to have property if and only if . A property of the functions and is a set of Turing machines such that for every two Turing machines and , if and for all , then either and are both in or neither of them are in . A property is nontrivial if and only if and there exists a Turing machine such that .
Czerwinski’s paper also makes use of the S-m-n Theorem in a number of its arguments. Since explaining the entire theorem would mean defining many concepts in computability theory that are unnecessary to the purpose of this critique, we suggest interested readers directly consult the book “Introduction to Metamathematics” by S.C. Kleene [Kle52].
2.1 Complexity Classes
We will now define the complexity classes that will appear throughout the critique.
is the class of languages that can be accepted by a deterministic Turing machine using a polynomial amount of space, formally defined as .
is the class of languages that can be decided by a deterministic Turing machine in polynomial time. Formally, .
and are both classes of languages that can be accepted by a deterministic Turing machine in exponential time. However, they are defined differently and represent two different classes of languages. Formally, and . , , and are related in the following ways: (1) , (2) [Boo74], and (3) .
An oracle can be thought of as a subroutine for determining membership in a certain set. An oracle Turing machine is a modified Turing machine that has the additional capability of querying an oracle. The actual construction of an oracle is generally unimportant and it can be thought of as a black box. If is an oracle and is an oracle Turing machine with oracle access to , then we use the notation .
2.2 Reductions and Completeness
We will define several reductions adapted from the definitions provided by Watanabe [Wat85]. Many of these definitions can be found in earlier works. A set many-one reduces to , denoted , if there is a computable function such that .111Watanabe uses to denote polynomial-time many-one reductions, however, we have kept to the standard notation to differentiate between many-one reductions and polynomial-time many-one reductions. This reduction is called a polynomial-time many-one reduction when is computable in polynomial time on a deterministic Turing machine and is called a linear-time many-one reduction when is computable in linear time on a deterministic Turing machine, which are denoted by and respectively. This reduction is called a polynomial-time one-one reduction when is one-one and is computable in polynomial time, which is denoted by . A set is length-increasing polynomial-time one-one reducible to if is polynomial-time one-one reducible to via a length-increasing function, denoted as . A function is length-increasing if .
A language is -complete when and for all , . A language is -complete when and for all , . Finally, A language is -complete when and for all , .
3 On Section 1 of [Cze21]
In the first section of Czerwinski’s paper, four sets are defined [Cze21],
with the last two stated to be examples of -complete and -complete sets respectively. It should also be mentioned that one can easily prove that and are also respectively -complete and -complete. Following the definitions is Corollary 1
Corollary 1 ([Cze21]).
and .
Although this is correct, in later proofs there are no references made to this corollary. In addition, it is also difficult to see the importance of the sets and , with and already introduced as complete sets for their respective classes.
We note in passing that the author introduces a lemma, whose statement is true. Although the given proof contains minor errors, we omit this discussion as the next sections’ discussion is of greater importance.
After the lemma, a remark regarding the relativization barrier is given. The content of the remark offers little to no insight into how the paper plans to deal with the relativization barrier. Consequently, we assume that its sole purpose is to assure readers that the paper will take the possible issue with the relativization barrier into consideration later on in Section 5 of the paper.
4 On Section 2 of [Cze21]
Section 2 of Czerwinski’s paper focuses on undecidability when considering properties of time and space complexity. First, two notations are introduced, and , which we have defined in Section 2 of our critique. Afterwards, two inequalities concerning and are presented, which are taken from a paper by Hopcroft, Paul, and Valiant [HPV77]. For an arbitrary single-tape deterministic Turing machine and an arbitrary input where halts on , it holds that:
Nonetheless, it is unclear how this result is applied to the arguments made in this paper, as it does not seem to be used by any of the proofs.
The paper then introduces its first theorem.
Theorem 1 ([Cze21]).
For an arbitrary TM , any nontrivial property of the functions and is undecidable.
The theorem seems to be a modification of the well-known Rice’s theorem [Ric53]. Instead of using nontrivial semantic properties like in Rice’s theorem [Ric53], the theorem considers nontrivial properties of the functions and , which are the space and time complexity of on some input .
We present a counterexample of Theorem 1. Let is a Turing machine and and , and . It is easy to see that this property is nontrivial: There exists some Turing machines that satisfy , which implies , and there exists a Turing machine that only uses one tape space on some input and a Turing machine that only runs for one step before halting on some input , which implies is not in . We will describe the decider for as follows.
The reason why can accept after running the th step is because if only uses the first tape cell and there are different tape characters, then there are only different configurations of space. Consequently, if runs more than steps using only the first tape cell, then we can be certain that is looping forever within that cell. Apart from this, it should be easy to see how always halt and .
The proof of Theorem 1 has a faulty assumption that for any TM and any nontrivial property of the functions and , and on any input , the exact value of and are needed to check property . However, in the counterexample that we created, calculating neither the exact space complexity nor the exact time complexity was necessary in deciding whether a Turing machine is in .
Corollary 2 ([Cze21]).
Let be a function with
and
It is undecidable if
Unfortunately, as we have already shown that Theorem 1 is flawed, the proof of Corollary 2 is incomplete, thus its correctness is not guaranteed.
We continue to the findings of the next and final part of this section, Corollary 3.
Corollary 3 ([Cze21]).
If one wants to show that an arbitrary TM does not accept an input within steps, a computational cost of is needed in the worst case.
While reading the proof of the corollary, we notice that the proof does not address the correctness of Corollary 3. Instead, the proof tries to set up another nontrivial property of the function for an arbitrary Turing machine , and, based on Theorem 1, concludes that it is undecidable. It should also be recognized that Corollary 3 is in fact correct. Briefly speaking, the reason why checking whether a Turing machine accepts an input within steps might require a runtime of is because the overhead from simulating on could raise the total runtime to be bigger than .
5 On Section 3 of [Cze21]
We will now critique Section 3 of Czerwinski’s paper. In this section, the paper presents findings related to length-increasing functions and reductions.
Czerwinski’s paper defines length-increasing functions similarly to Section 2 of our critique, with one additional requirement of having a polynomial-time computable inverse.
The paper next introduces Theorem 2, which is adapted from one of the results of Watanabe’s paper “On one-one polynomial time equivalence relations” [Wat85].
Theorem 2 ([Cze21]).
If and are -complete, then and hold.
As a proof for this theorem, Czerwinski cites the proof of Corollary 3.4 from Watanabe’s paper [Wat85]. It should be noted that at the time of Watanabe’s paper, it was standard to define to represent what we have defined as . As a result, Watanabe’s paper only provides a proof where and are -complete, rather than being -complete. Czerwinski’s paper does not provide a preliminaries section, so it is unclear if the paper intends to use or . However, we believe its main goal is to separate and , as the result is already well-known [Boo74]. Moreover, Watanabe [Wat85] does not define length-increasing functions to be necessarily polynomial-time invertible, which is different from the definition given in Czerwinski’s paper. For these reasons, the proof of Theorem 2 is invalid. This is a critical flaw in Czerwinksi’s paper since the result of Theorem 2 sets the stage for Theorem 3 to be able to show that . We will discuss this more in Section 6.
Next, we will critique Lemma 2.
Lemma 2 ([Cze21]).
Let and . Then there is a length-increasing reduction222Originally in Czerwinski’s paper, is stated to be a length-increasing function. However, if is simply a length-increasing function, then the if and only if condition that follows is flawed in that it mishandles cases of strings that are syntactically not of the form . Therefore, we suspect what the author intends is for to be a length-increasing reduction instead. Since this does not significantly affect the critique, we leave it as a footnote. such that:
where depends only on .
Before going into the proof, we would like to introduce some notations that the author uses. Functions and are defined as and , and thus . By the S-m-n theorem, and . Additionally, by Czerwinski’s definition of a length increasing function, is polynomial-time invertible, and thus .
We would like to focus on the pseudocode given at the end of the proof.
This pseudocode is provided as an algorithm in which can be constructed and simulated on without using , thus making it depend only on . To our understanding, given as some input, the algorithm will construct that, if defined, satisfies that . Afterwards, can be constructed with . However, this construction does not prove the statement of the lemma. The lemma claims that only depends on , while the provided pseudocode also uses in its calculation.
6 On Section 4 of [Cze21]
The main result is presented in Section 4 of Czerwinski’s paper.
Theorem 3 ([Cze21]).
There is no -reduction from to .
It is crucial to see that in order for this theorem to imply that , then Theorem 2 must hold. Theorem 2 proposes that all -complete sets are length-increasing polynomial-time one-one reducible to each other. Hypothetically, if Theorem 2 was in fact true, then one would only need to show that there is no length-increasing polynomial-time one-one reduction from a -complete set, , to a -complete set, , to prove that is not -complete and thus , which is the statement of Theorem 3. As we have identified the problems with Theorem 2 earlier, if Theorem 3 were to hold, it would not be strong enough to imply that . Additionally, the proof of this theorem also uses Lemma 2 and Corollary 2, which we have shown to be invalid. As a result, we can say that this proof is similarly incomplete, and ultimately, the paper fails to show that .
7 On Section 5 of [Cze21]
In this section, Czerwinski attempts to argue that the proof technique does not violate the relativization barrier. In order to do this, he introduces Proposition 1.
Proposition 1 ([Cze21]).
There is a computable function such that with exponential computation time.
As a proof for this proposition, the paper provides pseudocode that takes a problem from and computes a set in in exponential time. The pseudocode seems correct, however the proposition itself is trivial. It is unclear how this proposition demonstrates that the purported proof technique does not violate the relativization barrier.
The paper claims that the existence of this function being a many-one reduction that is computable but not computable in polynomial-time “means , but and so, ” [Cze21]. Prior to this point, the paper has not directly made the claim that so it is unclear how the existence of a exponential time reduction prevents a polynomial time one from existing. In fact, the existence of a polynomial-time many-one reduction would imply the existence of a exponential-time many-one reduction.
The claim that implies that is correct, however it is unclear why the paper uses the classes with the oracles rather than the classes directly as more directly implies that which then implies since and .
8 Conclusion
In this critique, we have pointed out errors in “Separation of and ” [Cze21] and come to the conclusion that the paper fails to show that . The paper makes several mistakes in its reasoning and thus is unable to provide a sufficient proof for its key claim. As a result, it is still an open issue whether .
Acknowledgements
We would like to especially thank Michael C. Chavrimootoo for his helpfulness during the development of our critique and his helpful comments on previous drafts. We would also like to thank Ethan Ferland, Lane A. Hemaspaandra, and David E. Narváez for their helpful comments on prior drafts. The authors are solely responsible for any remaining errors.
References
- [AB09] S. Arora and B. Barak. Complexity Theory: A Modern Approach. Cambridge University Press, 2009.
- [Boo74] R. Book. Comparing complexity classes. Journal of Computer and System Sciences, 3(9):213–229, 1974.
- [Cze21] R. Czerwinski. Separation of PSPACE and EXP. Technical Report arXiv:2104.14316 [cs.CC], Computing Research Repository, arXiv.org/corr/, April 2021. Version 1.
- [HO02] L. Hemaspaandra and M. Ogihara. The Complexity Theory Companion. Springer-Verlag, 2002.
- [HPV77] J. Hopcroft, W. Paul, and L. Valiant. On time versus space. Journal of the ACM, 24(2):332–337, April 1977.
- [Kle52] S. Kleene. Introduction to Metamathematics. D. van Nostrand Company, Inc., 1952.
- [Ric53] H. Rice. Classes of recursively enumerable sets and their decision problems. Transactions of the American Mathematical Society, 74(2):358–366, 1953.
- [Sip13] M. Sipser. Introduction to the Theory of Computation. Cengage Learning, 3rd edition, 2013.
- [Wat85] O. Watanabe. On one-one polynomial time equivalence relations. Theoretical Computer Science, 38:157–165, 1985.