# Turing-Complete vs Turing-Universal

I think people often confuse the concept of Turing-Complete with Turing-Universal.

Turing-universality is the property a [universal Turing machine](https://en.wikipedia.org/wiki/Universal_Turing_machine) (UTM) has:[^vxm3ce9joql]

**Turing-universality:** an abstract machine[^p2vnj3ikw1r] $U$ is Turing-universal if and only if, for any Turing machine $T$, there is a sequence of bits $p_T$ which can be fed into $U$ after which $U$ exactly imitates $T$.

That is: a Turing-universal machine can be programmed to precisely imitate any Turing machine. 

[Turing-completeness](https://en.wikipedia.org/wiki/Turing_completeness), on the other hand, works as follows:

**Turing-completeness:** a mathematical object (such as an abstract machine, a formalism for computation, a cellular automaton, a video game, etc.) is Turing-complete if and only if it can be used to simulate any computable function.

The word "emulation" might replace "simulation" above.

Some critical differences:

*   Turing-universality only applies to abstract machines. (Indeed, it is usually only applied to Turing machines, although we can easily generalize a little further.) Turing-completeness applies to anything which can be made mathematically precise.
*   To be eligible for Turing-universality, you've got to already be accepting *bits* as input & producing them as output.[^84fvqn6gnqb] Turing-universality requires that you can mimic a Turing machine precisely *with no translation.* Turing-completeness is far more generous; it is commonly applied to things that don't deal in bits.
*   Turing-universality is precisely defined. Turing-completeness relies on the informal notion of "simulation".

The reason for these differences is that Turing-universality is a notion for use within the study of Turing machines, to show that there's something like a programmable computer in the formalism. Turing-completeness, on the other hand, is a notion for *comparing different formalisms for computation*. It would not be appropriate to require the input/output to be in bits, since bits are an arbitrary choice of the formalism.

As a consequence, Turing-completeness is an inherently weaker property. This has important learning-theoretic consequences. For example, the prototypical example of a Turing-complete formalism is lambda calculus. The prototypical example of a prior based on Turing machines is Solomonoff's prior. Someone not familiar with the distinction between Turing-complete and Turing-universal might naively think that a prior based on lambda calculus would be equally powerful. It is not so. Solomonoff's prior guarantees a *constant* Bayes loss compared to the best computable prior for the job. In contrast, a prior based on lambda calculus can guarantee only a *multiplicative* loss.[^h6xpkpnpuoh]

Turing-completeness is also *less well-specified*, because the notion of "simulation" is informal. As far as I know, [there are still open debates in philosophy about whether a bucket of water is "simulating" a human mind](https://plato.stanford.edu/entries/computation-physicalsystems/#UnlPan) (making computationalist metaphysics effectively trivial -- basically, affirming Dust Theory from Permutation City).

More concretely: are the digits of $\pi$ Turing-complete?[^ps1ujcj1mg] Argument in favor: we must be allowed some computation, in order to find the outputs of a computation in our chosen formalism and translate them. We can use this computation to search for whatever answers we want in the digits of $\pi$.[^wjst8cp518a]

The above two examples are silly, sure, but there are real cases where the ambiguity matters. Specifically, I've heard there was controversy about Matthew Cook's proof that Wolfram's "rule 110" is Turing-complete. (I haven't been able to find a good reference for this, however.)

I think it isn't difficult to come up with rules which block obvious bad arguments, but I believe there is still some ambiguity about what counts as a valid "simulation" for this purpose. How much computation is allowed in the steps where you translate between formalisms? How do we rule out using this computation "illegitimately" (sneaking the computational work the so-called Turing-complete formalism was supposed to do into the translation step, as with the argument for Turing-completeness of digits of $\pi$)?

*Note: although I think the terminology here follows easily from commonly given definitions of Turing-complete and of universal Turing machine, it is not entirely standard. When I try to search the internet for good references on these matters, I commonly see people using "universal" when they clearly mean what I here call "Turing-complete" -- EG* [*Wikipedia's article on Lambda calculus*](https://en.wikipedia.org/wiki/Lambda_calculus)*. LLMs also don't make the distinction the way I'm making it here; in my tests, they either don't make a firm distinction, or they say that Turing-completeness applies to formalisms while universality applies to a single machine. (I think this is typically true, but not the right principled distinction to point out; for one thing, a formalism can be such that it has just a single machine within it, and still be Turing-complete.)*

[^vxm3ce9joql]: The phrase "universal Turing machine" is common in the literature, but "Turing-universal" is not. I think the common practice is to just say "universal" as in "We can prove that this machine is universal by considering...". However, while this usage is clear enough in an appropriate context, it seems better for the general term to stipulate that the universality is across Turing machines, so I'm saying "Turing-universal" here. 

[^p2vnj3ikw1r]: An abstract machine is just a mathematically specified machine (in contrast to some specific physical machine). 

[^84fvqn6gnqb]: We can also define Turing-universality for machines which use other alphabets, but this results in a distinct notion of universality (universal over a different class); a UTM which is universal over ternary machines is not, technically, universal over binary machines (although we can easily emulate binary machines with a lightwate translation). 

[^h6xpkpnpuoh]: The reason: a universal turing machine can be "locked in" to behaving like a target Turing machine \(T\), given just the bits of the program \(p_T\). Solomonoff's prior therefore merely has to learn those bits, to imitate any other (computable) prior.Lambda calculus, on the other hand, cannot be "locked in" in this way. We can construct the machine \(T\), of course, and we can simulate \(T\)'s behavior by feeding it translated 1s and 0s. (The standard translation of 0 is \(\lambda f x. x\), and 1 is \(\lambda f x. f x\).) However, there's no way to create a directive forcing simulated-T to only be fed simulated-bits. A lambda-calculus-based prior might "try to be clever" by finding regularities in the bits, EG, encoding one hundred zeros in a row via a more compact term which expands to one hundred simulated-zeros.This might sound like an advantage, but it isn't. It means there's no way to learn precisely and only the regularity represented by \(T\) in lambda calculus. The universal Turing machine can also do the clever thing where it compresses one hundred zeros together, but it is a distinct hypothesis. This makes universal machines strictly more powerful, learning-theoretically, than lambda calculus. 

[^ps1ujcj1mg]: Philip Parker introduced me to this argument. 

[^wjst8cp518a]: I don't think this bad argument is too hard to refute, but I don't have the energy right now.