Showing papers on "Turing machine published in 1989"

Time/space trade-offs for reversible computation

Abstract: A reversible Turing machine is one whose transition function is $1:1$, so that no instantaneous description (ID) has more than one predecessor. Using a pebbling argument, this paper shows that, for any $\varepsilon > 0$, ordinary multitape Turing machines using time T and space S can be simulated by reversible ones using time $O(T^{1 + \varepsilon } )$ and space $O(S\log T)$ or in linear time and space $O(ST^\varepsilon )$. The former result implies in particular that reversible machines can simulate ordinary ones in quadratic space. These results refer to reversible machines that save their input, thereby insuring a global $1:1$ relation between initial and final IDs, even when the function being computed is many-to-one. Reversible machines that instead erase their input can of course compute only $1:1$ partial recursive functions and indeed provide a Godel numbering of such functions. The time/space cost of computing a $1:1$ function on such a machine is equal within a small polynomial to the cost of co...

Two applications of inductive counting for complementation problems

Abstract: Following the recent independent proofs of Immerman [SIAM J. Comput., 17 (1988), pp. 935–938] and Szelepcsenyi [Bull. European Assoc. Theoret. Comput. Sci., 33 (1987), pp. 96–100] that nondeterministic space-bounded complexity classes are closed under complementation, two further applications of the inductive counting technique are developed. First, an errorless probabilistic algorithm for the undirected graph s-t connectivity problem that runs in $O(\log n)$ space and polynomial expected time is given. Then it is shown that the class LOGCFL is closed under complementation. The latter is a special case of a general result that shows closure under complementation of classes defined by semi-unbounded fan-in circuits (or, equivalently, nondeterministic auxiliary pushdown automata or tree-size bounded alternating Turing machines). As one consequence, it is shown that small numbers of “role switches” in two-person pebbling can be eliminated.

Deciding ML typability is complete for deterministic exponential time

Abstract: A well known but incorrect piece of functional programming folklore is that ML expressions can be efficiently typed in polynomial time. In probing the truth of that folklore, various researchers, including Wand, Buneman, Kanellakis, and Mitchell, constructed simple counterexamples consisting of typable ML programs having length n, with principal types having O(2cn) distinct type variables and length O(22cn). When the types associated with these ML constructions were represented as directed acyclic graphs, their sizes grew as O(2cn). The folklore was even more strongly contradicted by the recent result of Kanellakis and Mitchell that simply deciding whether or not an ML expression is typable is PSPACE-hard.We improve the latter result, showing that deciding ML typability is DEXPTIME-hard. As Kanellakis and Mitchell have shown containment in DEXPTIME, the problem is DEXPTIME-complete. The proof of DEXPTIME-hardness is carried out via a generic reduction: it consists of a very straightforward simulation of any deterministic one-tape Turing machine M with input k running in O(c|k|) time by a polynomial-sized ML formula PM,k, such that M accepts k iff PM,k is typable. The simulation of the transition function d of the Turing Machine is realized uniquely through terms in the lambda calculus without the use of the polymorphic let construct. We use let for two purposes only: to generate an exponential amount of blank tape for the Turing Machine simulation to begin, and to compose an exponential number of applications of the ML formula simulating state transition.It is purely the expressive power of ML polymorphism to succinctly express function composition which results in a proof of DEXPTIME-hardness. We conjecture that lower bounds on deciding typability for extensions to the typed lambda calculus can be regarded precisely in terms of this expressive capacity for succinct function composition.To further understand this lower bound, we relate it to the problem of proving equality of type variables in a system of type equations generated from an ML expression with let-polymorphism. We show that given an oracle for solving this problem, deciding typability would be in PSPACE, as would be the actual computation of the principal type of the expression, were it indeed typable.

Multiparty protocols and logspace-hard pseudorandom sequences

Abstract: Let ƒ(x1, ···· xk) be a Boolean function that k parties wish to collaboratively evaluate. The i'th 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 O(n·c-k), for the number of bits that need to be exchanged in order to compute some (explicitly given) functions in P. Our bounds hold even if the parties only wish to have a 1% advantage at guessing the value of ƒ on random inputs. We then give several applications of our lower bounds.Our 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√logn) that no Logspace Turing machine will be able to distinguish from truly random sequences. As a corollary we give an explicit construction of universal traversal sequence of length exp(exp(c√logn)) for arbitrary undirected graphs on n vertices.We then apply the multiparty protocol lower bounds to derive several new time-space tradeoffs. We give a tight time-space tradeoff of the form TS=T(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 tradeoff 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).

Nearly linear time

Abstract: The notion of linear-time computability is very sensitive to machine model. In this connection, we introduce a class NLT of functions computable in nearly linear time n(log n)O(1) on random access computers. NLT is very robust and does not depend on the particular choice of random access computers. Kolmogorov machines, Schonhage machines, random access Turing machines, etc., also compute exactly NLT functions in nearly linear time. It is not known whether usual multitape Turing machines are able to compute all NLT functions in nearly linear time. We do not believe they are and do not consider them necessarily appropriate for this relatively low complexity level. It turns out, however, that nondeterministic Turing machines accept exactly the languages in the nondeterministic version of NLT. We give also a machine-independent definition of NLT and a natural problem complete for NLT.

Computational Models of Games

Abstract: Because games and game-like phenomena occur naturally in a computational setting, it is natural to formulate many problems in Computer Science in terms of games. In order to understand their complexity, various models of computation have been developed which reflect the game-like properties of such problems. These models include the alternating Turing machines of Chandra, Kozen, and Stockmeyer (CKS81), the games against nature of Papadimitriou (PAP83), the Arthur-Merlin games of Babai (BAB85), and the interactive proof systems of Goldwasser, Micali, and Rackoff (GMR85). We unify and extend the work on these game-like models of computation. We define a new computational model of two person games, called a probabilistic game automaton. Three important features of games are included in the definition: randomness, secrecy and limited power for the players. Probabilistic game automata are defined as language acceptors, where the input is accessible to both players. We prove a number of results on the complexity of some classes of languages accepted by special types of game automata encompassed by our model. To state these results precisely, we use a consistent notation throughout the dissertation. Some of these results are summarized here. In our notation, we let UP, (UC) denote the class of two-person games with unbounded two-sided error and partial information (complete information), where one player plays randomly. Hence, UC refers to games against known nature and UP refers to games against unknown nature. We show that ATIME(poly(n)) = UC--TIME(poly(n)) = UP--TIME(poly(n)) and ASPACE(poly(n)) = UC--SPACE(poly(n)) $\subseteq$ UP--SPACE(log((n))), where ATIME and ASPACE refer to alternating Turing machines and poly(n) is any polynomial function of n. Here and in the results below we assume that the space and time bounds are deterministically constructible. We also prove a number of new results on the power of the space bounded analogues of Arthur-Merlin games and interactive proof systems. We denote these by BC and BP respectively, for probabilistic games with bounded error with complete and partial information, respectively. Our main results are that ASPACE(poly(n)) = BC--SPACE(poly(n)) $\subseteq$ BP--SPACE(log(n)). As a consequence, any language recognizable in deterministic exponential time has an interactive proof which uses only logarithmic space.

On counting and approximation

Abstract: We introduce a new class of functions, called span functions which count the different output values that occur at the leaves of the computation tree associated with a nondeterministic polynomial time Turing machine transducer This function class has natural complete problems; it is placed between Valiant's function classes #P and #NP, and contains both Goldberg and Sipser's ranking functions for sets in NP, and Krentel's optimization functions We show that it is unlikely that the span functions coincide with any of the mentioned function classes

Query complexity, or why is it difficult to separateNP A ∩coNP A fromP A by random oraclesA?

Abstract: By thequery-time complexity of a relativized algorithm we mean the total length of oracle queries made; thequery-space complexity is the maximum length of the queries made. With respect to these cost measures one can define polynomially time- or space-bounded deterministic, nondeterministic, alternating, etc. Turing machines and the corresponding complexity classes. It turns out that all known relativized separation results operate essentially with this cost measure. Therefore, if certain classes do not separate in the query complexity model, this can be taken as an indication that their relativized separation in the classical cost model will require entirely new principles. A notable unresolved question in relativized complexity theory is the separation of NPA∩ ∩ co NPA fromP A under random oraclesA. We conjecture that the analogues of these classes actually coincide in the query complexity model, thus indicating an answer to the question in the title. As a first step in the direction of establishing the conjecture, we prove the following result, where polynomial bounds refer to query complexity. If two polynomially query-time-bounded nondeterministic oracle Turing machines accept precisely complementary (oracle dependent) languages LA and {0, 1}*∖LA under every oracle A then there exists a deterministic polynomially query-time-bounded oracle Turing machine that accept LA. The proof involves a sort of greedy strategy to selecting deterministically, from the large set of prospective queries of the two nondeterministic machines, a small subset that suffices to perform an accepting computation in one of the nondeterministic machines. We describe additional algorithmic strategies that may resolve the same problem when the condition holds for a (1−e) fraction of the oracles A, a step that would bring us to a non-uniform version of the conjecture. Thereby we reduce the question to a combinatorial problem on certain pairs of sets of partial functions on finite sets.

The Turing Test: The Elusive Standard of Artificial Intelligence

Abstract: Origins of the Articles. Preface. 1: History. The Turing Test B. J. Copeland. Turing Test: 50 Years Later A.P. Saygin, I. Cicekli, V. Akman. 2: Interpretation. Turing's Two Tests for Intelligence S.G. Sterrett. Making the Right Identification in the Turing Test S. Traiger. Turing's Rules for the Imitation Game G. Piccinini. 3: Criticism. Passing Loebner's Turing Test: A Case of Conflicting Discourse Functions S. Zdenek. The Constructibility of Artificial Intelligence (as Defined by the Turing Test) B. Edmonds. Intelligence is not Enough: On the Socialization of Talking Machines E.M.A. Ronald. 4: Defense. How to Pass a Turing Test W.J. Rapaport. Look Who's Moving the Goal Posts Now L. Hauser. The Status and Future of the Turing Test J.H. Moor. 5: Alternatives. Creativity, the Turing Test, and the (Better) Lovelace Test S. Bringsjord, P. Bello, D. Ferrucci. The Cartesian Test for Automatism G.J. Erion. Minds, Machines and Turing S. Harnad.

Untyped sets, invention, and computable queries

Abstract: Conventional database query languages are considered in the context of untyped sets. The algebra without while has the expressive power of the typed complex object algebra. The algebra plus while, and COL with untyped sets (under stratified semantics or inflationary semantics) have the power of the computable queries. The calculus has power beyond the computable queries; and is characterized using the typed complex object calculus with invention. The Bancilhon-Khoshafian calculus is also discussed. A technical tool, called “generic Turing machine”, is introduced and used in several of the proofs.

Enumerative counting is hard

Abstract: An n-variable Boolean formula may have anywhere from 0 to 2n satisfying assignments. Can a polynomial-time machine, given such a formula, reduce this exponential number of possibilities to a small number of possibilities? We call such a machine an enumerator and prove that if there is a good polynomial-time enumerator for #P (i.e., one where for every Boolean formula f, the small set has at most O(|f|1−e) numbers), then P = NP = P# P and probabilistic polynomial time equals polynomial time. Furthermore, we show that #P polynomial-time Turing reduces to enumerating #P.

A 1-Tape 2-Symbol Reversible Turing Machine

Abstract: Bennett proved that any irreversible Turing machine can be simulated by a reversible one. However, Bennett' s reversible machine uses 3 tapes and many tape symbols. Previ­ ously, Gono and Morita showed that the number of symbols can be reduced to 2. In this paper, by improving these methods, we give a procedure to convert an irreversible machine into an equivalent 1-tape 2-symbol reversible machine. First, it is shown that the \"state-degeneration degree\" of any Turing machine can be reduced to 2 or less. Using this result and some other tech­ niques, a given irreversible machine is converted into a 1-tape 32-symbol (i. e., 5-track 2-symbol) reversible machine. Finally the 32-symbol machine is converted into a 1-tape 2-symbol reversible machine. From this result, it is seen that a 1-tape 2-symbol reversible Turing machine is computation universal.

A general sequential time-space tradeoff for finding unique elements

Abstract: An optimal O(n2) lower bound is shown for the time-space product of any R-way branching program that determines those values which occur exactly once in a list of n integers in the range [1, R] where R ≥ n. This O(n2) tradeoff also applies to the sorting problem and thus improves the previous time-space tradeoffs for sorting. Because the R-way branching program is a such a powerful model these time-space product tradeoffs also apply to all models of sequential computation that have a fair measure of space such as off-line multi-tape Turing machines and off-line log-cost RAMs.

On the undecidability of splicing systems

Abstract: The notion of splicing system has been used to abstract the process of DNA digestion by restriction enzymes and subsequent religation. A splicing system language is the formal language of all DNA strings producible by such a process. The membership problem is to devise an algorithm (if possible) to answer the question of whether or not a given DNA string belongs to a splicing system language given by initial strings and enzymes. In this paper the concept of a sequential splicing system is introduced. A sequential splicing system differs from a splicing system in that the latter allows arbitrarily many copies of any string in the initial set whereas the sequential splicing system may restrict the initial number of copies of some strings. The main result is that there exist sequential splicing systems with recursively unsolvable membership problem. The technique of the proof is to embed Turing machine computations in the languages.

A subgrouping strategy that reduces complexity and speeds up learning in recurrent networks

Abstract: An algorithm, called RTRL, for training fully recurrent neural networks has recently been studied by Williams and Zipser (1989a, b). Whereas RTRL has been shown to have great power and generality, it has the disadvantage of requiring a great deal of computation time. A technique is described here for reducing the amount of computation required by RTRL without changing the connectivity of the networks. This is accomplished by dividing the original network into subnets for the purpose of error propagation while leaving them undivided for activity propagation. An example is given of a 12-unit network that learns to be the finite-state part of a Turing machine and runs 10 times faster using the subgrouping strategy than the original algorithm.

Simulation of Turning Machines by a Left-Linear Rewrite Rule

Abstract: We prove in this paper that for every Turing machine there exists a left-linear, variable preserving and non-overlapping rewrite rule that simulates its behaviour. The main corollary is the undecidability of the termination for such a rule. If we suppose that the left-hand side can be unified with an only subterm of the right-hand side, then termination is decidable.

The theory of functions and sets of natural numbers

Abstract: Recursiveness and Computability. Induction. Systems of Equations. Arithmetical Formal Systems. Turing Machines. Flowcharts. Functions as Rules. Arithmetization. Church's Thesis. Basic Recursion Theory. Partial Recursive Functions. Diagonalization. Partial Recursive Functionals. Effective Operations. Indices and Enumerations. Retraceable and Regressive Sets. Post's Problem and Strong Reducibilities. Post's Problem. Simple Sets and Many-One Degrees. Hypersimple Sets and Truth-Table Degrees. Hyperhypersimple Sets and Q-Degrees. A Solution to Post's Problem. Creative Sets and Completeness. Recursive Isomorphism Types. Variations of Truth-Table Reducibility. The World of Complete Sets. Formal Systems and R.E. Sets. Hierarchies and Weak Reducibilities. The Arithmetical Hierarchy. The Analytical Hierarchy. The Set-Theoretical Hierarchy. The Constructible Hierarchy. Turing Degrees. The Language of Degree Theory. The Finite Extension Method. Baire Category. The Coinfinite Extension Method. The Tree Method. Initial Segments. Global Properties. Degree Theory with Jump. Many-One and Other Degrees. Distributivity. Countable Initial Segments. Uncountable Initial Segments. Global Properties. Comparison of Degree Theories. Structure Inside Degrees. Bibliography. Index.

Finiteness Conditions on Subgroups and Formal Language Theory

Abstract: We show in this article that the most usual finiteness conditions on a subgroup of a finitely generated group all have equivalent formulations in terms of formal language theory. This correspondence gives simple proofs of various theorems concerning intersections of subgroups and the preservation of finiteness conditions in a uniform manner. We then establish easily the theorems of Greibach and of Griffiths by considering free reductions of languages that describe the computations of pushdown automata in one case and of Turing machines in the other, thus making clear that they are essentially the same.

An Efficient Software Protection Scheme

Abstract: In 1979 Pippenger and Fischer [PF] showed how a two-tape Turing Machine whose head positions (as a function of time) are independent of the input, can simulate, on-line, a one-tape Turing Machine with a logarithmic slowdown in the running time. We show a similar result for random-access machine (RAM) model of computation. In particular, we show how to do an on-line simulation of arbitrary RAM program by probabilistic RAM whose memory access pattern is independent of the program which is being executed with a poly-logarithmic slowdown in the running time.A main application of our result concerns software protection, one of the most important issues in computer practice. A theoretical formulation of the problem for a generic one-processor, random-access machine (RAM) model of computation was given by Goldreich [G]. In this paper, we present a simple and an efficient software protection scheme for this model. In particular, we show how to protect any program at the cost of a poly-logarithmic slowdown in the running time of the protected program, previously conjectured to be impossible.

Automata Theory Meets Circuit Complexity

Abstract: The last 25 years have seen the growth of an elaborate theory elucidating the connections between combinatorial properties of classes of rational languages and algebraic properties of the finite automata which recognize these languages (see for instance [Sc65, Ei74, Pi84]). In the same period, Turing machine-based computational complexity theory has uncovered a number of difficult questions which, like P versus NP or Logspace versus P, remain unanswered today (see [HoU179]). In response to such challenges (see for instance [Jo86]), and as a result of the need to model parallelism (see [Co85]), much effort recently went into the study of the computing power of polynomial size Boolean circuit families. When Furst, Saxe and Sipser showed in [FuSaSi81] that such circuit families of unbounded fan-in and constant-depth (class A C °) were strictly less powerful than their bounded fanin and logarithmic-depth counterparts (class NC1), hopes were raised that important new separation results might be at hand. Though indeed the (highly non-trivial) exponential

Complex Computing with Cellular Automata

Abstract: There are two equally acceptable ways to describe the computational universe of cellular automata (CA), depending on whether one chooses to emphasize homogeneity or multiplicity. These two complementary approaches reflect a relationship between the organizational notions of insulation and interaction.

On Dice and Coins: Models of Computation for Random Generation

Abstract: To distinguish between random generation in bounded, as opposed to expected, polynomial time, a model of Probabalisic Turing Machine (PTM) with the ability to make random choices with any (small) rational bias is necessary. This ability is equivalent to that of being able to simulate rolling any k-sided die (where |k| is polynomial in the length of the input). We would like to minimize the amount of hardware required for a machine with this capability. This leads to the problem of efficiently simulating a family of dice with as few different types of biased coins as possible.

Behavior and Structure

Abstract: Philosophers and scientists frequently distinguish between the behavior and the structure of an organism. In automata theory the distinction can be made quite exactly, and provides for a concept of level of structure; at the low end is the material structure and at the high the abstract rule structure. Having developed the idea of various levels in relatively sharp form we go on to distinguish between rules that somehow guide and those that just describe a system, and also between models and theories. Finally I defend a realistic thesis: embodied automata rules are really in, or constitute, the mind.

La constitution de la théorie des automates

Abstract: In the years 1965, the process of the constitution of the "theory of automata", a logico-algebraical study of the computing devices which can be used as mathematical models for information processing machines, was completed. In spite of its theoretical connection with the Turing machine, the enterprise did, however, not take the form of an explicit topic until 1948, when Von Neumann proposed to handle within the framework of a general "logical" theory a whole set of questions stemming from various domains, spreading from biology to computers. The study of finite automata, in the decade 1950-1960, was then the first to impose an organisation on these disconnected achievements in the form of a coherent abstract theory, endowed with manageable algebraical and logical tools. As a counterpart, Turing's approach of calculability gave rise to a theory of infinite machines (whose architectonics was brought gradually closer to that of actual machines), which was to be quickly extended by a computational complexity theory. Finally, in the sixties, joining the combinatorial-algorithmic tradition of post and Markov, the syntactical analysis of natural and programming languages gave the decisive impulse, through the theory of formal grammars, to the study of "bounded-infinite" automata, in particular pushdown and linear bounded automata.