 Turing completeness

For the usage of this term in the theory of relative computability by oracle machines, see Turing reduction.
In computability theory, a system of datamanipulation rules (such as an instruction set, a programming language, or a cellular automaton) is said to be Turing complete or computationally universal if and only if it can be used to simulate any singletaped Turing machine and thus in principle any computer. A classic example is the lambda calculus. The concept is named after Alan Turing.
In practice, Turing completeness means that the rules followed in sequence on arbitrary data can produce the result of any calculation. In procedural languages this can be satisfied by having, at a minimum, conditional branching (e.g., an "if" and "goto" statement) and the ability to change arbitrary memory locations (e.g., variables). To show that something is Turing complete, it is enough to show that it can be used to simulate the most primitive computer, since even the simplest computer can be used to simulate the most complicated one. All general purpose programming languages and modern machine instruction sets are Turing complete, notwithstanding finitememory limitations.
A universal computer is defined as a device with a Turing complete instruction set, infinite memory, and an infinite lifespan. All realworld systems necessarily have finite memory, making the true universal computer a theoretical construct.
In computability theory, there is a closely related concept known as Turing equivalence. Two computers P and Q are called Turing equivalent if P can simulate Q and Q can simulate P. Thus, a Turingcomplete system is one that can simulate a Turing machine, but the term is most often used to mean Turing equivalent to a Turing machine. The reason is that any real world computer can be simulated by a Turing machine, an observation codified as the Church–Turing thesis.
A computer with access to an infinite tape of data is sometimes more powerful than a Turing machine, because the tape can in principle contain the solution to the halting problem, or some other undecidable problem. An infinite tape of data is called a Turing oracle. Even a Turing oracle with random data is not computable (with probability 1), since there are only countably many computations but uncountably many oracles. So a computer with a random Turing oracle can compute things that a Turing machine cannot. A machine which is universal except for having access to some Turing oracle is called weakly universal.
Contents
Formal definitions
In computability theory, several closely related terms are used to describe the computational power of a computational system (such as an abstract machine or programming language):
 Turing completeness
 A computational system that can compute every Turingcomputable function is called Turing complete (or Turing powerful). Alternatively, such a system is one that can simulate a universal Turing machine.
 Turing equivalence
 A Turingcomplete system is called Turing equivalent if every function it can compute is also Turing computable; i.e., it computes precisely the same class of functions as do Turing machines. Alternatively, a Turingequivalent system is one that can simulate, and be simulated by, a universal Turing machine. (All known Turingcomplete systems are Turing equivalent, which adds support to the Church–Turing thesis.)
 (Computational) universality
 A system is called universal with respect to a class of systems if it can compute every function computable by systems in that class (or can simulate each of those systems). Typically, the term universality is tacitly used with respect to a Turingcomplete class of systems. The term "weakly universal" is sometimes used to distinguish a system (e.g. a cellular automaton) whose universality is achieved only by modifying the standard definition of Turing machine so as to include input streams with infinitely many 1s.
Overview
Turing completeness, named after Alan Turing, is significant in that every realworld design for a computing device can be simulated by a universal Turing machine. The Church–Turing thesis states that this is a law of nature—that a universal Turing machine can, in principle, perform any calculation that any other programmable computer can. Obviously, this says nothing about the effort needed to write the program, or the time it may take for the machine to perform the calculation, or any abilities the machine may possess that have nothing to do with computation.
While truly Turingcomplete machines need unlimited amounts of working memory, Turing completeness is often loosely attributed to physical machines or programming languages that would be universal if they had unlimited storage and addressing. All modern computers are Turing complete in this loose sense, they are linear bounded automaton complete.
Charles Babbage's analytical engine (1830s) would have been the first Turingcomplete machine if it had been built at the time it was designed. Babbage appreciated that the machine was capable of great feats of calculation, including primitive logical reasoning, but he did not appreciate that no other machine could do better. From the 1830s until the 1940s, mechanical calculating machines such as adders and multipliers were built and improved, but they could not perform an "if/goto" and therefore are not true computers.
In the late 19th century, Leopold Kronecker formulated notions of computability, defining primitive recursive functions. These functions can be calculated by rote computation, but they are not enough to make a universal computer, because the instructions which compute them do not allow for an infinite loop. In the early 20th century, David Hilbert led a program to axiomatize all of mathematics with precise axioms and precise logical rules of deduction which could be performed by a machine. Soon, it became clear that a small set of deduction rules are enough to produce the consequences of any set of axioms. These rules were proved to be enough to produce every theorem by Kurt Gödel in 1930. Gödel's completeness theorem of 1930 implicitly contains a definition of a universal computer, because the logical rules acting on some axioms of arithmetic will eventually prove as a theorem the result of any computation.
The actual notion of computation was isolated soon after, starting with Gödel's incompleteness theorem. This theorem showed that axiom systems were limited when reasoning about the computation which deduces their theorems. Church then Turing identified the computational core of the incompleteness theorem, and were able to produce undecidable problems. This work, along with Gödel's work on general recursive functions, established that there are sets of simple instructions, which, when put together, are able to produce any computation. The work of Gödel showed that the notion of computation is essentially unique.
John von Neumann was inspired by these results to design actual working universal computing machines. The first formal programming languages of the 1930s demonstrated that such a computer would be useful. The first actual implementation of a Turingcomplete machine appeared in 1941: the programcontrolled Z3 of Konrad Zuse, but the first machine explicitly designed to be Turing complete and widely appreciated as being universal was the 1946 ENIAC. This machine was able to solve a wide range of effective problems in the 1940s, many related to atomic bomb design.
All known laws of physics have consequences which are computable by a series of approximations on a digital computer. A hypothesis called digital physics states that this is no accident, that it is because the universe itself is computable on a universal Turing machine. This would imply that no computer more powerful than a universal Turing machine can be built physically (see philosophical implications in the Church–Turing thesis).
Computability theory
The first result of computability theory is that it is impossible in general to predict what a Turingcomplete program will do over an arbitrarily long time. For example, it is impossible to determine for every programinput pair whether the program, operating on the input, will eventually stop or will continue forever (see halting problem). It is impossible to determine whether the program will return "true" or whether it will return "false". For any characteristic of the program's eventual output, it is impossible to determine whether this characteristic will hold. This can cause problems in practice when analyzing realworld computer programs. One way to avoid this is to cause programs to stop executing after a fixed period of time, or to limit the power of flow control instructions. Such systems are not Turing complete by design.
Another theorem shows that there are problems solvable by Turingcomplete languages that cannot be solved by any language with only finite looping abilities (i.e., any language that guarantees every program will eventually finish to a halt). Given a guaranteed halting language, the computable function which is produced by Cantor's diagonal argument on all computable functions in that language is not computable in that language.
Examples
The computational systems (algebras, calculi) that are discussed as Turing complete systems are those intended for studying theoretical computer science. They are intended to be as simple as possible, so that it would be easier to understand the limits of computation. Here are a few:
 Automata theory
 Universal Turing machine
 Lambda calculus
 Formal grammar (language generators)
 Formal language (language recognizers)
 Rewrite system
 Post–Turing machines
Most programming languages, conventional and unconventional, are Turingcomplete. This includes:
 All generalpurpose languages in wide use.
 Procedural programming languages such as Pascal.
 Objectoriented languages such as Java, Smalltalk.
 Multiparadigm languages such as Ada, C++, Common Lisp, Object Pascal.
 Most languages using less common paradigms
 Functional languages such as Lisp and Haskell.
 Logic programming languages such as Prolog.
 Declarative languages such as XSLT.^{[1]}
 Esoteric programming languages, such as brainfuck.
The specific language features used to achieve Turing completeness can be quite different; Fortran systems would use loop constructs or possibly even goto statements to achieve repetition; Haskell and Prolog, lacking looping almost entirely, would use recursion. Turing completeness is an abstract statement of ability, rather than a prescription of specific language features used to implement that ability.
Turing completeness in SQL is implemented through advanced standard features, illustrating one reason relatively powerful nonTuringcomplete languages are rare: the more powerful the language is initially, the more complex are the tasks to which it is applied and the sooner its lack of completeness becomes perceived as a drawback, encouraging its extension until it is Turing complete.
The untyped lambda calculus is Turing complete, but many typed lambda calculi, including System F, are not. The value of typed systems is based in their ability to represent most typical computer programs while detecting more errors.
Rule 110 and Conway's Game of Life, both cellular automata, are Turing complete.
NonTuringcomplete languages
Many computational languages exist which are not Turing complete. One such example is the set of regular languages, most commonly regular expressions, which are generated by finite automata. A more powerful but still not Turingcomplete extension of finite automata is the category of pushdown automata and contextfree grammars, which are commonly used to generate parse trees in an initial stage of program compiling. Further examples include some of the early versions of the pixel shader languages embedded in Direct3D and OpenGL extensions,^{[citation needed]} or a series of mathematical formulae in a spreadsheet with no cycles.^{[citation needed]}
In some languages, all functions are total, and must terminate, such as Charity and Epigram. Charity uses a type system and control constructs based on category theory, whereas Epigram uses dependent types.
Data languages
Languages such as XML, JSON, YAML and Sexpressions are not Turing complete because they are only used to represent structured data, not describe computation. These are sometimes referred to as markup languages, or more properly as "data description languages".
NonTuring complete languages, especially data languages, are desirable in that they can be manipulated, which, however, also applies to some Turingcomplete languages, most notably Lisp and many of its dialects like Scheme. This is codified in the web design principle known as the "Rule of Least Power", which recommends avoiding the use of Turing complete languages, and in fact using the least powerful language that satisfies a task, so that the result data can more easily be reused and transformed.
See also
 Loop (computing)
 Inner loop
 Smn theorem
 Church–Turing thesis
 Computability theory
 Algorithmic information theory
 Chomsky hierarchy
 Machines that always halt
 Stephen Wolfram's A New Kind of Science
 Principle of Computational Equivalence
 Turing tarpit
 Structured program theorem
References
 ^ "Universal Turing Machine in XSLT". unidex.com. http://www.unidex.com/turing/utm.htm. Retrieved 20100705.
 Brainerd, W.S., Landweber, L.H. (1974), Theory of Computation, Wiley. ISBN 0471095850
 Simplest 'universal computer' wins student $25,000 by Jim Giles, New Scientist, October 24, 2007.
 The Universal Turing Machine: A HalfCentury Survey (1995), ed. Rolf Herken, Springer Verlag. ISBN 3211826378
External links
Wikimedia Foundation. 2010.