Turing Machine Complexity Research Articles

Sign-rank Can Increase under Intersection

The communication class UPP cc is a communication analog of the Turing Machine complexity class PP . It is characterized by a matrix-analytic complexity measure called sign-rank (also called dimension complexity), and is essentially the most powerful communication class against which we know how to prove lower bounds. For a communication problem f , let f ∧ f denote the function that evaluates f on two disjoint inputs and outputs the AND of the results. We exhibit a communication problem f with UPP cc ( f ) = O (log n ), and UPP cc ( f ∧ f ) = Θ (log 2 n ). This is the first result showing that UPP communication complexity can increase by more than a constant factor under intersection. We view this as a first step toward showing that UPP cc , the class of problems with polylogarithmic-cost UPP communication protocols, is not closed under intersection. Our result shows that the function class consisting of intersections of two majorities on n bits has dimension complexity n Omega Ω(log n ) . This matches an upper bound of (Klivans, O’Donnell, and Servedio, FOCS 2002), who used it to give a quasipolynomial time algorithm for PAC learning intersections of polylogarithmically many majorities. Hence, fundamentally new techniques will be needed to learn this class of functions in polynomial time.

On store languages of language acceptors

It is well known that the “store language” of every pushdown automaton — the set of store configurations (state and stack contents) that can appear as an intermediate step in accepting computations — is a regular language. Here many models of language acceptors with various store structures are examined, along with a study of their store languages. For each model, an attempt is made to find the simplest model that accepts their store languages. Some connections between store languages of one-way and two-way machines are demonstrated, as with connections between nondeterministic and deterministic machines. A nice application of these store language results is also presented, showing a general technique for proving families accepted by many deterministic models are closed under right quotient with regular languages, resolving some open questions (and significantly simplifying proofs for others that are known) in the literature. Lower bounds on the space complexity of Turing machines for having non-regular store languages are obtained.

Recursion versus tail recursion over [formula omitted

We characterize the intrinsically recursive functions over the algebraic closure of a finite field in terms of Turing machine complexity classes and derive some structural properties about the family of such functions. In particular, we show that the domain of convergence of any partial recursive function is again recursive, and, under complexity-theoretic hypotheses, that the class of tail recursive functions is strictly smaller than the class of recursive functions (cf. Theorems 5.4, 5.2, and Section 8).Underlying these results is the “meta-result” that we can perform a limited amount of arithmetic inside the field itself, with no access to a separate sort of natural numbers.

On relationships between complexity classes of Turing machines

Classes of time and space complexity of Turing machines are defined, and relationships between them are discussed. New relationships between the defined complexity classes are described.

Verifying time complexity of Turing machines

We show that, for all reasonable functions T(n)=o(nlog⁡n), we can algorithmically verify whether a given one-tape Turing machine runs in time at most T(n). This is a tight bound on the order of growth for the function T because we prove that, for T(n)≥(n+1) and T(n)=Ω(nlog⁡n), there exists no algorithm that would verify whether a given one-tape Turing machine runs in time at most T(n).As opposed to one-tape Turing machines, we show that we can verify whether a given multi-tape Turing machine runs in time at most T(n) iff T(n0)<(n0+1) for some n0∈N.We also prove a very general undecidability result stating that, for any class of functions F that contains arbitrary large constants, we cannot verify whether a given Turing machine runs in time T(n) for some T∈F. This is an extension of the following folkloric results: we cannot verify whether a Turing machine runs in constant, linear or polynomial time.

Two-Way Automata Versus Logarithmic Space

We strengthen a previously known connection between the size complexity of two-way finite automata ([InlineEquation not available: see fulltext.]) and the space complexity of Turing machines (tms). Specifically, we prove that Here, [InlineEquation not available: see fulltext.] and [InlineEquation not available: see fulltext.] are the deterministic and nondeterministic [InlineEquation not available: see fulltext.], NL and L/poly are the standard classes of languages recognizable in logarithmic space by nondeterministic tms and by deterministic tms with access to polynomially long advice, and NLL and LL/polylog are the corresponding complexity classes for space O(loglogn) and advice length poly(logn). Our arguments strengthen and extend an old theorem by Berman and Lingas and can be used to obtain variants of the above statements for other modes of computation or other combinations of bounds for the input length, the space usage, and the length of advice.

A Comparison of Resource-Bounded Molecular Computation Models

The number of molecular strands used by a molecular algorithm is an important measure of the algorithm's complexity. This measure is also called the volume used by the algorithm. We prove that three important polynomial-time models of molecular computation with bounded volume are equivalent to models of polynomial-time Turing machine computation with bounded nondeterminism. Without any assumption, we show that the Split operation does not increase the power of polynomial-time molecular computation. Assuming a plausible separation between Turing machine complexity classes, the Amplify operation does increase the power of polynomial-time molecular computation.

Relations between communication complexity classes

We study the complexity of communication between two processors in terms of complexity classes as introduced by Babai, Frankl, and Simon ( in “Proceedings, 27th Annu. IEEE Sympos. on Found. of Comput. Sci., 1986,” pp. 337–347). They showed some analogies between Turing machine (TM) classes like P, NP , Σ k etc. and the corresponding communication complexity classes which we denote by C- P , C- NP , C- Σ k etc. This paper continues these investigations, in particular, the Boolean hierarchy C- BH and probabilistic classes are considered. We enlarge this correspondence by showing that C- Σ k+1 can also be characterized by a C- NP -protocol that uses only one question to a C- Σ k -oracle. For the probabilistic class C- PP it suffices to consider probabilistic protocols with moderately bounded error, this solves an open problem suggested in op. cit. In contrast to the case of TM complexity, we are able to show some proper inclusions like C- BH ∪ C- BPP ⊂ C- Σ 2 ∩ C- π 2 ν C- PP and C- PP ⊂ C- P c-# P . The nonuniformity of communication protocols allows us to show that the Boolean communication hierarchy does not collapse.

A generalized Grzegorczyk hierarchy and low complexity classes

We recall the notion of the generalized Grzegorczyk hierarchy and we discuss some problems connected with its initial classes. We establish equalities between initial generalized Grzegorczyk classes and some Turing machine complexity classes such as P and P ∗ LINSPACE. Using the means of Grzegorczyk classes we prove a certain hierarchy theorem for the class P ∗ LINSPACE. Stack Turing machines are introduced for better description of low complexity classes.

Uniform normal form for general time-bounded complexity classes

Refining techniques of previous works, we obtain a normal form arithmetical representation for non-deterministic computability, in which the polynomial matrix does not involve the time-bounding function. This permits arithmetization of Turing machine complexity classes determined by quite general time bounds. Applications are made to complexity hierarchies and to obtain a single, uniform, normal form.

Relations between diagonalization, proof systems, and complexity gaps

In this paper we study diagonal processes over time bounded computations of one-tape Turing machines by diagonalizing only over those machines for which there exist formal proofs that they operate in the given time bound. This replaces the traditional “clock” in resource bounded diagonalization by formal proofs about running times and establishes close relations between properties of proof systems and existence of sharp time bounds for one-tape Turing machine complexity classes. These diagonalization methods also show that the Gap Theorem for resource bounded computations can hold only for those complexity classes which differ from the corresponding provable complexity classes. Furthermore, we show that there exist recursive time bounds T( n) such that the class of languages for which we can formally prove the existence of Turing machines which accept them in time T( n) differs from the class of languages accepted by Turing machines for which we can prove formally that they run in time T( n). We also investigate the corresponding problems for tape bound computations and discuss the difference time and tapebounded computations.

On Relating Time and Space to Size and Depth

Turing machine space complexity is related to circuit depth complexity. The relationship complements the known connection between Turing machine time and circuit size, thus enabling us to expose the related nature of some important open problems concerning Turing machine and circuit complexity. We are also able to show some connection between Turing machine complexity and arithmetic complexity.

The Tape Comilexity of Some Classes of Szilard Languages

In this paper we discuss lower and upper bounds for the tape complexity of Turing machines which recognize some classes of Szilard languages. The main results are as follows: $\log n$ is the optimal tape bound for on-line deterministic Turing machines which recognize Szilard languages of context-free grammars, and it is also the optimal tape bound for off-line deterministic Turing machines which recognize leftmost Szilard languages of phrase structure grammars. The Szilard language of an arbitrary phrase structure grammar is a deterministic context-sensitive language.

The network complexity and the Turing machine complexity of finite functions

Let L(f) be the network complexity of a Boolean function L(f). For any n-ary Boolean function L(f) let $$TC(f) = min\{ T_p^{\bar A} (n){\text{ (}}\parallel p\parallel + 1gS_p^{\bar A} {\text{(}}n{\text{):}}res_p^{\bar A} {\text{(}}n{\text{) = }}f\} $$ . Hereby p ranges over all relative Turing programs and ă? ranges over all oracles such that given the oracle ă?, the restriction of p to inputs of length n is a program for L(f). ?p? is the number of instructions of p. T p ă? (n) is the time bound and S p ă? of the program p relative to the oracle ă? on inputs of length n. Our main results are (1) L(f) ? O(TC(L(f))), (2) TC(f) ? O(L(f) 2 2+?) for every ? ? O.

The state complexity of Turing machines

Given a number of tape symbols, we define the state complexity of a partial-recursive function f as the minimal number of states necessary for a Turing machine that computes f . A similar definition gives us the state complexity of recursively enumerable sets and hence of abstract languages. We can show that all complexity classes are non-empty and finite. If a certain value of complexity is surpassed, then every language-complexity class contains at least one language of each of the following types: finite, nonfinite regular, nonregular context-free, context-sensitive but not context-free, recursive but not context-sensitive, enumerable but not recursive. The state complexity of a function or language is closely related to the amount of description or information needed to define the function or language.