The Power of One-State Turing Machines

TL;DR

This paper explores the computational power of one-state Turing machines, demonstrating they can recognize complex languages beyond regular and context-free, surpassing pushdown automata in certain tasks.

Contribution

It extends previous results by proving one-state Turing machines can recognize non context-free languages, showing greater computational power than previously known.

Findings

One-state Turing machines can accept non regular languages.

They can recognize some non context-free languages.

They are more powerful than pushdown automata for certain tasks.

Abstract

At first glance, one-state Turing machines are very weak: the halting problem for them is decidable, and, without memory, they cannot even accept a simple one element language such as $L = \{ 1 \}$ . Nevertheless it has been showed that a one-state Turing machine can accept non regular languages. We extend such result and prove that they can also recognize non context-free languages, so for some tasks they are more powerful than pushdown automata.

Equations

$$L(M)=\{x\mid M\text{ halts on input x}\}$$

$$L_{cc}=\{x\mid M_{cc}(x)\text{ halts}\}$$

$$L_{u0h}=\{u^n{0}^{m}h\mid n,m\ge 0\}$$

$$L_{cc}^{\prime }=\{u^n{0}^{m}h\mid n,m\ge 0\wedge n\ge 2^m-1\}$$

$$L_{cc}^{\prime }\subseteq L_{u0h}$$

$$L_{cc}^{\prime }\subseteq L_{cc}\cap L_{u0h}$$

$$s=u^{2^p-1}{0}^{p}h$$

$$u^{2^p-p}(u^{p-1}{)}^n(0^1{)}^n{0}^{p-1}h\in L_{cc}^{\prime }$$

$$2^p-p+n(p-1)<2^{n+p-1}-1$$

$$R\not\subset T{M}_{1state},T{M}_{1state}\not\subset CF$$

Full text

1 Introduction

A Turing machine with two states is able to simulate any Turing machine; hence we can build a two–states universal Turing machine (actually 2 states and 18 symbols are enough to achieve universality [4]) hence the halting problem for them is undecidable. We dramatically clips their wings if we allow only one state: we get a device with no internal memory and the halting problem becomes decidable [1, 5]. We cannot even distinguish between accepting and non–accepting states. Nevertheless we can relax the notion of acceptance and rejection of an input: a one–state Turing machine accepts a string $x$ if it halts; it rejects $x$ if it runs forever. Under this different notion of acceptance, a one–state Turing machine is more powerful than finite–state automata [2]. In [3] Kudlek considers languages accepted by Turing machines with one state and three symbols, and with two states and two symbols. He proves that one state Turing machines with 3 symbols accept regular languages, except in one case a deterministic linear context-free language.

We extend such result and prove that a one–state Turing machine is more powerful than a pushdown automata, too: it can recognize non context–free languages.

In Section 2 we give some preliminary definitions, in Section 3 we build a one–state Turing machine that is able to compare two numbers in different bases, in Section 4 we give a formal proof that the language recognized by such machine is not context–free.

2 Definitions

We use the standard definition of Turing machine as a 7-tuple [6]:

Definition 2.1** (Turing Machine).**

A Turing machine $M$ is a 7-tuple $\langle Q,\Sigma,\Gamma,q_{0},q_{a},q_{r},\delta\rangle$ where $Q$ is the set of states, $\Sigma$ is the input alphabet not containing the blank symbol $\sqcup$, $\Gamma$ is the tape alphabet, $\sqcup\in\Gamma,\Sigma\subseteq\Gamma$, $q_{0}\in Q$ is the initial state, $q_{a}\in Q$ is the accept halting state, $q_{r}\in Q$ is the reject halting state ($q_{r}\neq q_{a}$), $\delta:Q\setminus\{q_{a},q_{r}\}\times\Gamma\to Q\times\Gamma\times\{L,R\}$ is the transition function that given a non-halting state and the current symbol returns a new (possibly halting) state, a symbol that is written on the tape and the direction of the move ($Left$ or $Right$).

The single head of the Turing machine is placed on a tape with an infinite number of cells in both directions; at the beginning of the computation the state of the Turing machine is $q_{0}$, the head is placed on the leftmost symbol of the input string; the rest of the cells contain the blank symbol $\sqcup$.

With two states and 18 symbols ($|Q|=2,|\Gamma|=18$) we can build an universal Turing machine [4]; we restrict our study to one–state Turing machines so $|Q|=1$ [2, 5]. But with only one state available we cannot neither distinguish between an accepting and rejecting state nor between a non–halting and a halting state; so we must somewhat alter the standard definition of accept/reject:

Definition 2.2** (One–state Turing machine).**

A one state Turing machine is a 6-tuple:

$\langle\{q\},\Sigma,\Gamma,q,H,\delta\rangle$ where $q$ is the only state which is also the initial state, $\Sigma$ is the input alphabet not containing the blank symbol $\sqcup$, $\Gamma$ is the tape alphabet, $\sqcup\in\Gamma,\Sigma\subseteq\Gamma$, $H$ is the set of halting symbols, $\delta:\Gamma\setminus H\to\Gamma\times\{L,R\}$ is the transition function that given the current symbol under the head, returns the new symbol to be written and the direction of the move. If the current symbol is a halting symbol, the machine halts.

We define the language recognized by a one–state Turing machine:

Definition 2.3** (Language recognized by a one–state Turing machine).**

If $M$ is a one–state Turing machine, $x\in\Sigma^{*}$, we define the language recognized by $M$ the set:

[TABLE]

.

We could also consider the variant in which the one–state Turing machine is equipped with distinct sets of accept and reject halting symbols. In this case the behavior can be: halt and accept, halt and reject or run forever. However it is straightforward to see that the results would also extend to this model.

At first glance, a one–state Turing machine is very weak, indeed it cannot even recognize trivial regular languages:

Theorem 2.4**.**

No one–state Turing machine $M$ can recognize the trivial regular language $L=\{1\}$.

Proof.

Suppose that $M$ recognizes $L=\{1\}$; we analyze its behavior on input $x=1$. At the beginning of the computation the head is on the symbol $1$, if it is a halting symbol then $M$ halts, but it will also halt and accept on any string $x=1^{+}$. If it is not a halting symbol, either $\delta(1)=(a_{1},L)$ (i) or $\delta(1)=(a_{1},R)$ (ii), $a_{1}\in\Gamma$.

• (i)

Suppose that $\delta(1)=(a_{1},L)$: now the head is on a blank symbol; if it is halting, then again it will also halt and accept on any $x=1^{+}$; it cannot move left again otherwise it will never halt; so it must move back to the right, i.e. $\delta(\sqcup)=(a_{\sqcup},R),a_{\sqcup}\in\Gamma$. At this point the head is on symbol $a_{1}$ (written on the first step); if $\delta(a_{1})=(a_{1}^{\prime},R)$ then the head will end on a blank symbol on the right part of the tape and it will start an infinite sequence of right moves. So $a_{1}$ must be halting or move the head to the left: $a_{1}\in H\lor\delta(a_{1})=(a_{1}^{\prime},L)$; in either cases $M$ would also halt on any string $x=1^{+}$.

• (ii)

If $\delta(1)=(a_{1},R)$ the behavior is similar: the head falls on a blank symbol and it must halt or jump back. If it halts, then $M$ would halt on any $x=1^{+}$ after a sequence of right moves. If it jumps back, it cannot move left again on $a_{1}$ otherwise it would fall on a blank symbol on the left part of the input moving forever. So we must have $\delta(\sqcup)=(a_{\sqcup},L)$ and $a_{1}\in H\lor\delta(a_{1})=(a_{1}^{\prime},R)$ ; but such transitions cause $M$ to halt and accept also all $x=1^{+}$.

In all cases $L(M)\setminus\{1\}\neq\emptyset$ leading to a contradiction. ∎

Nevertheless, as showed in [2], there are one–state Turing machines that can recognize non–regular languages, i.e. some of them are more powerful than finite–state automata.

In the next sections we will prove that they are even more powerful.

3 A powerful one–state Turing machine

A one–state Turing machine has no internal memory, but the symbols on the tape cells can be used to store the following information:

• •

cell has been visited $n\bmod k$ times ($k$ fixed);

• •

head has left the cell going to the right;

• •

head has left the cell going to the left.

This information is limited, but it is enough to implement both an unary counter and a binary counter. Informally we define a Turing machine with this behavior:

• •

the input is divided in two parts: the left part ($U^{*}$) is an unary counter; whenever the head finds a $U$ it marks it as counted writing $C$ and bounces back to the right part;

• •

the right part ($0^{*}$) – initially filled with [math]s – is a binary counter: whenever the head finds a zero [math] it transforms it to a $1$ and bounces back to the left part; when it finds a $1$ it marks it as a zero $Z$ and continues towards the right to “propagate” the carry; when going back to the left part it will change $Z$ to [math];

• •

at the (rightmost) end of the input there is the special symbol $h$ for which no transition is defined and causes the machine to halt.

Formally, we define a one–state Turing machine $M_{cc}=\langle\{q\},\Sigma,\Gamma,q,\{h\},\delta\rangle$ over a three symbols input alphabet $\Sigma=\{u,0,h\}$; the tape alphabet has eight symbols: $\Gamma=\{\sqcup,u,U,h,0,1,Z,C,B\}$; the complete transition table $\delta:\Gamma\to\Gamma\times\{L,R\}$ is:

[TABLE]

Figure 1 shows an example of a computation on input $uuuu00h$.

We call $L_{cc}$ the language defined by the inputs on which the Turing machine $M_{cc}$ halts (i.e. reach the halting symbol $h$ for which no transition is defined and doesn’t run forever):

[TABLE]

We don’t need to characterize exactly the language $L_{cc}$; but if we restrict the input to strings of the form $u^{*}0^{*}h$, we can prove the following property:

Theorem 3.1**.**

If $x\in\{u^{n}0^{m}h\mid n,m\geq 0\}$ then $x\in L_{cc}$ if and only if $n\geq 2^{m}-1$.

Proof.

By construction the left part $u^{n}$ behaves like an unary counter; while the right part $0^{m}$ behaves like a binary counter. For every increment of the binary counter the unary counter is also incremented, so the head can reach the rightmost $h$ only if $n\geq 2^{m}-1$; if $n<2^{m}-1$ then the head reaches the blank symbol on the left of the input and continues in that direction forever. ∎

We can say that, if the input is “well-formed”, the one–state Turing machine can compare a number represented in unary with a number represented in binary.

Using a similar technique we could build a one–state Turing machine that implements an arbitrary $k$-ary counter or a one–state Turing machine that compare a $k$-ary number with a $k^{\prime}$-ary number, i.e. it can compare two numbers written in different bases.

4 Computational complexity

We define the languages:

[TABLE]

[TABLE]

which, by Theorem 3.1, are related to each other and to $L_{cc}$ in this way:

[TABLE]

[TABLE]

We can prove that $L_{cc}$ is not context–free (CF) using the well known property of context–free languages: if $L$ is CF and $R$ is regular then $L\cap R$ is CF.

The following is immediate:

Lemma 4.1**.**

$L_{u0h}=\{u^{n}0^{m}h\mid n,m\geq 0\}$* is regular.*

and using the pumping lemma for context–free languages we prove the following:

Lemma 4.2**.**

$L^{\prime}_{cc}$* is not context–free.*

Proof.

Suppose that $L^{\prime}_{cc}$ is CF. Let $p\geq 1$ be the pumping length. We pick the string

[TABLE]

which is in $L^{\prime}_{cc}$. By the pumping lemma $s$ can be written as $s=rvwxy$, with substrings $r,v,w,x$ and $y$, such that i) $|vwx|\leq p$, ii) $|vx|\geq 1$, and iii) $rv^{n}wx^{n}y\in L^{\prime}_{cc}$ for all $n\geq 0$. We can have the following cases:

• •

$vwx$ is entirely contained in $u^{2^{p}-1}$; in this case we can pump zero times ($n=0$) and we get the string $s^{\prime}=u^{k}0^{p}h$ with $k<2^{p}-1$, hence $s^{\prime}\notin L^{\prime}_{cc}$;

• •

$vwx$ is entirely contained in $0^{p}$; in this case we can pump two times ($n=2$) and we get the string $s^{\prime}=u^{2^{p}-1}0^{j}h$ with $p<j$ and $2^{p}-1<2^{j}-1$, hence $s^{\prime}\notin L^{\prime}_{cc}$;

• •

$vwx$ spans between $u^{2^{p}-1}$ and $0^{p}$; in the worst case $v=u^{p-1}$ and $x=0^{1}$:

[TABLE]

should hold for any $n\geq 0$, but for large enough $n$ we have:

[TABLE]

which puts the string out of the language. So we can conclude that $L^{\prime}_{cc}$ is not context–free.

∎

We can finally conclude that the language recognized by the one–state Turing machine $M_{cc}$ is not context–free:

Theorem 4.3**.**

$L_{cc}$* is not context–free.*

Proof.

Suppose that $L_{cc}$ is CF. Then $L_{cc}\cap L_{u0h}$ is CF because $L_{u0h}$ is regular (Lemma 4.1). But $L_{cc}\cap L_{u0h}=L^{\prime}_{cc}$ which is not CF (Lemma 4.2) leading to a contradiction. ∎

If $R$ is the class of regular languages, $CF$ is the class of Context–Free languages, and $TM_{1state}$ is the class of languages recognized by one–state Turing machines; by Theorem 2.4 and Theorem 4.3, we have :

Theorem 4.4**.**

[TABLE]

5 Conclusion

We proved that despite its limitations a one–state Turing machine can be used to implement a $k$-ary counter and “compare” two numbers written in different bases (the quotes are due to the non–standard definition of acceptance/reject of an input string). So the class of languages recognized by one–state Turing machines is neither a superset of the regular languages nor a subset of the context-free languages.

As a further investigation, we state the following problem: what is the minimal number $n$ of symbols needed by a one–state Turing machine to accept a non context-free language? It is known that $4\leq n\leq 8$: $4\leq n$ proved in [3] and $n\leq 8$ proved in this article.