From: Thomas Walker Lynch Date: Fri, 17 Jul 2026 14:35:01 +0000 (+0000) Subject: descent empty symbol section (finally) X-Git-Url: https://git.reasoningtechnology.com/%27%20%20%20resolved_path%20%20%20%27?a=commitdiff_plain;h=66567bf7f11d13298fb3466d3c340b7d20757936;p=TM-2026 descent empty symbol section (finally) --- diff --git a/document/book/TM-2026.html b/document/book/TM-2026.html index c426ea1..bb153c5 100644 --- a/document/book/TM-2026.html +++ b/document/book/TM-2026.html @@ -340,7 +340,7 @@

-The computation theoretic Turing Machine + The computation theoretic Turing Machine

The Hopcroft and Ullman Turing Machine

@@ -443,28 +443,32 @@

Although by definition each state transition matches one value under the head, as a practical matter, disjunctive selection is allowed via a comma list. A conjunctive phrasing for the state transition proposition would require stringing intermediate states in series.

-

The empty symbol

+

Blank, empty, SP

-

Turing described a clerk writing symbols into squares, with the option to erase them. He states, "In some of the configurations in which the scanned square is blank (i.e. bears no symbol) the machine writes down a new symbol on the scanned square: in other configurations it erases the scanned symbol."Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society, Series 2, Volume 42 (1936): 231. So Turing's original article uses blank to mean no symbol. Turing fairly consistently refers to "blanks" rather than to a symbol that represents a blank. However, thirty pages in, he does say this, "for in the complete configuration the symbols are all blanks"Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society, Series 2, Volume 42 (1936): 261..

+

Turing described a clerk writing symbols into squares, with the option to erase them. He states, "In some of the configurations in which the scanned square is blank (i.e. bears no symbol) the machine writes down a new symbol on the scanned square: in other configurations it erases the scanned symbol."Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society, Series 2, Volume 42 (1936): 231. So Turing's original article uses blank to mean no symbol. Later Turing says, "We also give numbers to the symbols ... in particular, blank = S₀ .." ibid: 239..

-

The more abstract concept here is that of a container. A piece of paper is a container for symbols. When it contains no symbols, the container is empty. Only when we say the container is a piece of paper does it make sense to call it blank. But we are speaking of abstractions, not of paper. The question is not one of blankness, rather it is the more abstract question of emptiness. As a point of perspective, when computation theory texts are translated into French, the blank symbol is called the "symbole vide", or literally "empty symbol". Hence, in the French context, paper as a container does not carry with it a distinct terminology in the first place. +

The more abstract concept here is that of a container. A piece of paper is a container for symbols. When it contains no symbols, the container is empty. Only when we say the container is a piece of paper does it make sense to call it blank. But we are speaking of abstractions, not of paper. The question is not one of blankness, rather it is the more abstract question of emptiness. As a point of perspective, when computation theory texts are translated into French, the blank symbol is called the "symbole vide", or literally "empty symbol", as apparently blank paper is empty.

-

So the actual question, which dates back to the very definition of the Turing Machine, is this: when a square from Turing's paper has not yet been written to, does it hold an empty symbol, or is it actually empty?

+

So the actual question, which dates back to the very definition of the Turing Machine, is this: when a square from Turing's paper, what we are calling a tape cell, has not yet been written to, does it hold an empty symbol, or is it actually empty?

-

As defined in texts such as Hopcroft and Ullman, a Turing Machine cannot function when a tape cell does not read a symbol, because the next state function is defined such that it must be given a symbol. A machine breaks if a scanned cell is void of symbols.

+

A Turing Machine cannot function when a tape cell does not read a symbol, because the next state function is defined to be given the read symbol as an argument. A Turing machine would be unresolvable, i.e. it would break, if a scanned cell were void of symbols.

-

Imagine a tape machine, called machine A, where, upon attempting to read an empty cell, the machine head instead returns a control symbol representing that the cell was empty. To accomplish this, the head would have to do some work; it would have to be able to detect emptiness, and then choose to return the empty symbol instead of a read value. This feature would fix the problem of not having any defined next state behavior for an empty cell. Furthermore, suppose the inverse process was also special in that upon attempting to write the empty symbol, the machine takes action, emptying the cell out. This would facilitate an erase operation.

+

So we might imagine a tape machine, called machine A, where, upon attempting to read an empty cell, the machine head instead returns a control symbol representing that the cell was empty. To accomplish this, the head would have to do some work; it would have to be able to detect emptiness, and then choose to return the empty symbol instead of a read value. This feature would fix the problem of not having any defined next state behavior for an empty cell. Furthermore, suppose the inverse process is also special in that upon attempting to write the empty symbol, the machine takes action, emptying the cell out. This would facilitate an erase operation.

Now imagine machine B, where a yet-to-be-used cell on a tape directly holds the empty symbol. Because it is merely another symbol, reads and writes occur exactly as they do for other symbols.

-

As long as the cost of the empty cell fix is constant time, the differences between machine A and machine B are computationally inconsequential. However, for machine A, the mathematician is greatly inconvenienced if he cares to write down the contents of the tape, as he will need some means of communicating that a tape cell is empty. As mathematicians are wont to do, he would invent a symbol to express this meaning. The cup, empty box, or null set symbol are all possible choices. Let us not lose sight of the level of analysis, however. We are discussing the computation theoretic Turing Machine, and doing so in the realm of forms. Given that our discussion is in the abstract, machines A and B are in fact the same, the only difference being that the description for machine A is less elegant. Thus, we will recognize that an empty tape, one that has not been written to, is full of empty symbols.

+

As long as the cost of the empty cell fix is constant time, the differences between machine A and machine B are computationally inconsequential. However, for machine A, the mathematician is greatly inconvenienced if he cares to write down the contents of the tape, as he will need some means of communicating that a tape cell is empty. As a mathematician is wont to do, he would invent a symbol to express this meaning. The cup, empty box, or null set symbol are all possible choices. As soon as a choice is made, the only difference between Turing Machine A and Turing Machine B becomes a translation step between the symbol that represents an empty cell, and the symbol that is used to communicate this same meaning to the Turing Machine. The same symbol could be used for both purposes, thus eliminating the need for the translation. When this is done Turing Machine A becomes identical to Turing Machine B.

+ +

To say that a tape cell has never been written, is to say that the history of the tape cell is known. But no history is required to look at a blank piece of paper and to know it has no symbols on it. In addition, Turing allows that a tape cell can be "erased", so an empty cell is not necessarily one that has never been written. There is no need know the full history of the cell, how many times it has been written and erased, rather only a single bit of information is required. This bit can be toggled when the cell is written, then toggled back when it is erased. This toggle can be the empty symbol existence. If the cell is marked as being empty, because it is holding the empty symbol, it is said to be empty, otherwise it is not. This is a description of machine B.

-

Computational theorists often describe a two-step process. First, a Turing Machine writes a string to be studied onto a tape initially filled with all empty symbols; second, the tape is moved to another Turing Machine whose purpose is to recognize a property of the string being studied. In this process, a tape is used as a communication medium, and it follows that communication theory can be applied to this messaging scenario. Messages sent on a channel must be formatted so they can be placed on the channel and later recovered. The specification for such structuring is called a communication protocol. The protocol implies a higher authority, as both the sender and the receiver must have knowledge of the same designed-in protocol. In a sense, a protocol is the meta-message sent before the message itself.

+

Thus it seems that no matter what is done to try and save the machine A model, it turns into machine B. There is a simple reason for this. No structural definition has been given for emptiness, rather its existence is pushed on to a symbol. Consequently, discussion of machine A always brings back the symbol.

-

The intention of placing the empty symbol in Γ but not in Σ appears to be that of making the empty symbol serve double duty: firstly as a default value for a cell that has never been written, and secondly as a control component of a communications protocol. This protocol was designed by mathematicians with the intention of making it impossible for programmers to send studied string messages that cannot always be recovered by a receiving recognizer Turing Machine. In short, the empty symbol is also being used as an in-band EOT (end of transmission) symbol.

+

Computational theorists often describe a two-step process. First, a Turing Machine writes a string to be studied onto a tape initially filled with all empty symbols; second, the tape is moved to another Turing Machine whose purpose is to recognize a property of the string being studied. In this process, a tape is used as a communication medium, so it follows that communication theory can be applied to this messaging scenario. Messages sent on a channel must be formatted so they can be placed on the channel and later recovered. The specification for such structuring is called a communication protocol. The protocol implies a higher authority, as both the sender and the receiver must have knowledge of the same designed-in protocol. In a sense, a protocol is the meta-message sent before the message itself.

-

However, if this is the intention, the protocol is flawed, because Turing Machines are bestowed with the ability to erase characters. An input machine could, for example, happily output an array of strings while using an arbitrary number of empty symbols to separate the elements of a variable-length array. A receiving machine could then not know how many elements it should try to recover, or when to say a separator is sufficiently long to no longer be considered a separator. Nothing in the Turing Machine definition prevents this.

+

The intention of the later innovation of placing the empty symbol in Γ but not in Σ appears to be that of making the empty symbol serve additional duty: firstly as a default value for a cell that has never been written, secondly to effect erasure, and now thirdly as a control component of a communications protocol. Accordingly then, this protocol was designed by mathematicians with the goal of making it impossible for programmers to send 'to be studied' string messages, that cannot always be recovered by a receiving recognizer Turing Machine. In short, the empty symbol is also being used as an in-band EOT (end of transmission) symbol.

+ +

However, if this is the intention, the protocol is flawed, because Turing Machines are bestowed with the ability to erase characters. An input machine could, for example, happily output an array of strings while using an arbitrary number of empty symbols to separate the elements of a variable-length array. It can put these empty symbols into the input, by first writing another symbol, then erasing it. A receiving machine could then not know how many elements it should try to recover, or when to say a separator is sufficiently long to no longer be considered a separator. Nothing in the Turing Machine definition prevents this.

Furthermore, the Universal Turing Machine can act as the aforementioned higher authority. In this case, Turing Machines, and sometimes their tapes, are written to a Universal Turing Machine's tape. Consequently, it is not only possible to want to terminate multiple strings in series, as mentioned in the prior paragraph; the termination issue itself is embedded in proofs such as the Halting Problem.

@@ -472,9 +476,15 @@

For the modified computational Turing machine presented later in this chapter, there will be a separate control alphabet, as for the Hopcroft-Ullman interpretation. However, due to the reasons presented in this section, that alphabet will be part of the alphabet Σ rather than distinct from it. Programmers then must explicitly design communication protocols that suit the problems they are working on, and those protocols become opaque for examination by a higher authority.

+

Thus, the empty symbol is to mean that a tape cell "bears no symbol", it is to be the initializer for blank tape, it is the symbol to write to make a tape cell empty, and it is an EOT marker when communicating tape input data. However, it can not do all these things.

+ +

Firstly, let us address the elephant in the room: if a tape cell is holding the empty symbol, it is not empty, certainly not in the sense of Turing's statement, "bears no symbol". So that purpose was chimeric. Secondly, reserving a symbol but placing it in Γ-Σ does not solve the communication protocol problem. Thirdly, writing an EOT marker over other data does not universally constitute "erasure", particularly when the abstract distinction between erasing a cell and merely overwriting its contents is never formally defined.

+ +

There is one pleasing property of the blank, the ersatz empty symbol, that is valuable and unique to it. It prints as a space in diagrams given in text books, and by Turing Machine simulators. There is an analogous symbolic system that also has this characteristic: the ASCII hex 20, called SP, prints as a space, leaving an area of the paper it is printed on blank. Perhaps a better name is then the SP symbol. However, at this point, SP is merely another symbol in the alphabet Σ, and if the programmer wants it he can put it there. If the programmer wants it to participate in protocols, he can design it in. It need not have any special place in the Turing Machine definition.

+

The unspecified symbol

-

In the first edition of this book, I introduced a "no read until after write" rule while working towards an architectural Turing Machine so as to sideline the empty symbol, because real machines do not have them. This did not replace the need for a communication protocol for sending messages between machines, but it did make it possible to remove the empty symbol from programmed controller definitions.

+

In the first edition of this book, I introduced a "read only after write" rule while working towards an architectural Turing Machine so as to sideline the empty symbol. This section presents a computation theoretic TTCA Turing Machine that intrinsically enforces the "read only after write" rule by giving built-in meaning to the unspecified symbol. The concept of unspecified then displaces the concept of empty for the Turing Machine tape cell.

The standard 9-track tape introduced by IBM in 1964 came from the factory unformatted. The format operation would write a header and an EOF marker to mark the end of the device file. Then, a standard library call such as open(), followed by write(), would write over the EOF marker, continue writing data, and finally append a new EOF marker, essentially pushing the EOF boundary back. EOF could be pushed back until the physical EOT marker was struck. This matches, in some ways, how the empty symbol is used on the computation theoretic Turing Machine in the Hopcroft and Ullman book if we consider it to be an EOF marker. However, a difference exists in that the real machine would never use an EOF to erase data characters.

@@ -521,7 +531,7 @@ QF = \{QF{·}\mathtt{initial}, QF{·}\mathtt{unspecified\_decision}\} -

Here middle dot acts as a namespace operator, N{·}x. By doing this we assure there will be no aliasing with the symbols provided by the programmer when he defines the programmed state controller.

+

Here the middle dot acts as a namespace operator, N{·}x. By doing this we assure there will be no aliasing with the symbols provided by the programmer when he defines the programmed state controller.

The set of predefined symbols:

@@ -535,6 +545,8 @@ AF = \{ & \mathtt{no\_op} \\ , & \mathtt{left} \\ , & \mathtt{right} \\ + , & \mathtt{read\_d} \\ + , & \mathtt{read\_g} \\ , & \mathtt{write\_σ}(σ) \\ , & \mathtt{write\_d} \\ , & \mathtt{write\_g} \} @@ -543,11 +555,10 @@

where σ must be in Σ.

-

The predefined action table. A set of pairs of the form:

+

The set of predefined symbols:

- λF = \{ \langle q_0, a \rangle, \dots \} + ΣF = \{ΣF{·}\mathtt{unspecified}, ΣF{·}\mathtt{on\_leftmost}\}
-

where q_0 is matched to the current state, and a is a member of AF.

The TTCA Turing Machine variables

@@ -566,272 +577,184 @@

The TTCA Turing Machine programmable part

-

- MP = (QP, ΣP, λP, δ, δ_1, δ_2) -

+
+ + MP = (QP, ΣP, λP, δ, δ_1, δ_2) + +
-

QP: A set of programmed state symbols.

+

A set of programmed state symbols:

+
+ QP +
-

ΣP: A set of programmed data symbols.

+

A set of programmed data symbols:

+
+ ΣP +
-

λP: The programmed actions. A set of pairs of the form \langle q_0, a \rangle, where q_0 is matched to the current state, and a is a member of AF.

+

The programmed actions. A set of pairs of the form:

+
+ λP = \{ \langle q_0, a \rangle, \dots \} +
+

where q_0 is matched to the current state, and a is a member of AF.

-

δ: A set of state transition triples; each triple is of the form \langle q_0, r.σ, q_1 \rangle. q_0 is matched to the current state of the machine. r.σ is a symbol in register r. q_1 is the next state. q_0 and q_1 come from the total set Q. σ comes from the total set Σ. r is either d or g.

+

A set of state transition triples; each triple is of the form:

+
+ δ = \{ \langle q_0, r{·}σ, q_1 \rangle, \dots \} +
+

where q_0 is matched to the current state of the machine. r{·}σ is a symbol in register r. q_1 is the next state. q_0 and q_1 come from the total set Q. σ comes from the total set Σ. r is either d or g.

-

δ_1: The default transition table. A set of state transition pairs; each pair is of the form \langle r.σ, q_1 \rangle. r.σ is a symbol found in the specified register, either d or g. q_1 will be taken as the next state.

+

The default transition table. A set of state transition pairs; each pair is of the form:

+
+ δ_1 = \{ \langle r{·}σ, q_1 \rangle, \dots \} +
+

where r{·}σ is a symbol found in the specified register, either d or g. q_1 will be taken as the next state.

-

δ_2: A default next state.

+

A default next state:

+
+ δ_2 +

The TTCA Turing Machine in total

-

- M = (Q, Σ, A, λ, δ, δ_0, δ_{00}) -

- -

Q: The complete set of states, uniting the fixed predefined states and the programmed states (QF \cup QP).

- -

Σ: The complete set of symbols, uniting the fixed control symbols and the programmed data symbols (ΣF \cup ΣP).

- -

A: The complete set of available actions the machine can execute. Because the operational mechanics are strictly architectural, this is exactly the fixed set AF.

- -

λ: The complete action table mapping states to actions, uniting the predefined actions and the programmed actions (λF \cup λP).

- -

δ: The highest priority programmed next-state transition rules, requiring both a matching state and a matching read symbol to gate the transition.

- -

δ_0: The secondary default transition rules, evaluated solely on the read symbol if δ yields no next state.

- -

δ_{00}: The final unconditional next state, taken if neither δ nor δ_0 provides a valid transition.

- - ------ - - The computation theoretic Turing Machine - -

The Hopcroft and Ullman Turing Machine

- -

This definition comes from Hopcroft and Ullman's book with some terminology only changes to make it flow into the text here John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison Wesley, 1979).. -

+
+ + M = (Q, Σ, A, λ, δ, δ_1, δ_2) + +
- - M = (Q, \Sigma, \Gamma, \delta, q_0, □, F) - +

The complete set of states, uniting the fixed predefined states and the programmed states:

+
+ Q = QF \cup QP +
-

Where the components have the following meanings:

+

The complete set of symbols, uniting the fixed control symbols and the programmed data symbols:

+
+ Σ = ΣF \cup ΣP +
- +

The complete set of available actions the machine can execute. Because the operational mechanics are strictly architectural, this is exactly the fixed set:

+
+ A = AF +
-

I have introduced the qualifier programmed in front of the finite state machine controller because each Turing Machine that accomplishes a different task has a different finite state machine controller. The rest of the Turing Machine remains fixed. Hence, when the mathematician defines a custom task controller, he is essentially programming the machine.

+

The complete action table mapping states to actions, uniting the predefined actions and the programmed actions:

+
+ λ = λF \cup λP +
-

Here the input alphabet is said to be a subset of a larger alphabet. This allows some symbols to be set aside and only used by the machine. In the architecture description given below, those symbols exclusive to the larger set are called control symbols. Hopcroft and Ullman have included the empty symbol as a control symbol. However, they have simultaneously listed it as a separate component.

+

The highest priority programmed next-state transition rules, requiring both a matching state and a matching read symbol to gate the transition:

+
+ δ +
-

State transitions are gated by the read value from the tape. Each state transition function includes actions to be taken, hence their programmable controller is a Mealy style state machine. The step action is mandatory, though it can be in either direction. The write action must be specified, but the write could be the same symbol that is read, hence it is actually an optional action.

+

The secondary default transition rules, evaluated solely on the read symbol if δ yields no next state:

+
+ δ_1 +
-

Hopcroft and Ullman explain a step of the machine by showing a representation of the tape with the state variable melded in to the left of the currently scanned symbol. Suppose \delta(q, X_i) = (p, Y, L); i.e., the next move is leftward. Then, -

+

The final unconditional next state, taken if neither δ nor δ_1 provides a valid transition:

+
+ δ_2 +
- - X_1 X_2 \cdots X_{i-1} q X_i X_{i+1} \cdots X_n \underset{M}{\vdash} X_1 X_2 \cdots X_{i-2} p X_{i-1} Y X_{i+1} \cdots X_n - -

So first the tape is X_1 X_2 \cdots X_{i-1} X_i X_{i+1} \cdots X_n, with the head over X_i, and in state q. Then after a step of the machine, the tape is X_1 X_2 \cdots X_{i-1} Y X_{i+1} \cdots X_n, with the head over X_{i-1}, and in state p. Thus X_i was overwritten with Y, and the head stepped left. -

+

The TTCA programmed string reverse

-

Here is the programmed controller for a Turing Machine that reverses a binary string.

+

Because the TTCA architecture cleanly separates the data path from the control path, and isolates actions into a Moore-style programmed controller, it is possible to definitively prove that reversing a string does not require inspecting the payload. The programmed controller only needs to recognize the structural boundaries of the data protocol.

- HU reverse machine +

In the Hopcroft and Ullman machine, the controller was forced to read the data payload, branching into parallel states. If the input alphabet were expanded from binary to the full ASCII set, that controller would require an explosion of state definitions just to ferry characters across the tape. The TTCA machine avoids this entirely. It uses the gate register g exclusively to scan for control symbols (the unspecified space, the EOM marker 'E', and the read marker '*'). When a payload character is encountered, the controller executes a \mathtt{read\_d} action, blind to the symbol's actual value, and carries that opaque data across the tape to deposit it using \mathtt{write\_d}.

-

Provided the site is still alive, the following YAML can be entered at TuringMachine.io to watch the machine run.

+

Here is the programmed controller for the TTCA string reverse. Because actions (λ) are bound to states rather than transitions, reading and stepping are distinct states, resulting in a strictly serialized execution.

```yaml - # Reverses a binary string using a single marker and an EOM terminator. - input: '11001' - blank: ' ' - start state: q0 + # TTCA String Reverse + # The payload alphabet is completely abstracted. The machine operates + # solely on structural markers. + + start state: q_scan_end_read + table: - # scan to the rightmost digit and place the EOM terminator 'E' - q0: - [0, 1]: R - ' ' : {write: 'E', L: q1} - - # process the rightmost unmarked digit, writing the uniform marker '*' - q1: - 0 : {write: '*', R: q2} - 1 : {write: '*', R: q3} - ' ': {R: q6} # all digits processed, begin cleanup - - # carry '0' to the right end - q2: - ['*', 'E', 0, 1]: R - ' ' : {write: 0, L: q4} - - # carry '1' to the right end - q3: - ['*', 'E', 0, 1]: R - ' ' : {write: 1, L: q4} - - # return all the way to the left blank space - q4: - ['*', 'E', 0, 1]: L - ' ' : {R: q5} - - # step right to find the next unmarked digit - q5: - [0, 1] : R - ['*', 'E']: {L: q1} - - # erase the markers and EOM terminator, leaving only the reversed string - q6: - ['*', 'E'] : {write: ' ', R: q6} - [0, 1, ' ']: {L: done} + # Phase 1: Scan to the rightmost end and place the EOM terminator 'E' + q_scan_end_read: + action: read_g + gate: + unspecified: q_scan_end_mark + next: q_scan_end_step + + q_scan_end_step: + action: right + next: q_scan_end_read + + q_scan_end_mark: + action: write_σ('E') + next: q_find_next_read + + # Phase 2: Walk left to find the next unprocessed payload symbol + q_find_next_read: + action: read_g + gate: + '*' : q_find_next_step + 'E' : q_find_next_step + unspecified: q_cleanup_read # All data processed, begin cleanup + next: q_load_d # Payload encountered + + q_find_next_step: + action: left + next: q_find_next_read + + # Phase 3: Pick up the unknown data symbol and mark its original location + q_load_d: + action: read_d + next: q_mark_read + + q_mark_read: + action: write_σ('*') + next: q_carry_right_read + + # Phase 4: Carry the opaque data rightward over payload and markers + q_carry_right_read: + action: read_g + gate: + unspecified: q_drop_d + next: q_carry_right_step + + q_carry_right_step: + action: right + next: q_carry_right_read + + # Phase 5: Deposit the data at the new end of the sequence + q_drop_d: + action: write_d + next: q_find_next_step # Return to Phase 2 + + # Phase 6: Erase the structural markers, leaving only the reversed string + q_cleanup_read: + action: read_g + gate: + '*' : q_cleanup_erase + 'E' : q_cleanup_erase + unspecified: done + next: done + + q_cleanup_erase: + action: write_σ('unspecified') + next: q_cleanup_step + + q_cleanup_step: + action: left + next: q_cleanup_read done: + action: no_op ``` -

This machine starts with the head on the leftmost symbol of the input string, requiring an empty symbol on both sides to operate. The machine begins by sweeping right to place an end of message marker, E, immediately after the string. It then enters a repetitive process: it walks left to locate the next unprocessed input symbol, overwrites it with an asterisk to mark it as read, and then carries that remembered value rightward to deposit it at the new end of the sequence. By executing this back-and-forth shuttle, the machine systematically builds the reversed string to the right of the E, finishing by sweeping through to erase its temporary markers.

- -

Reversing a string does not in general require knowing the constituent symbols; however, a Turing Machine is incapable of ignoring their actual values. The 1 and 0 here are explicitly stated in the state transitions, and specific states are reserved to keep track of which symbol is being transferred. Had the input alphabet been large, this controller would have required proportionally more states.

- -

Although by definition each state transition matches one value under the head, as a practical matter, disjunctive selection is allowed via a comma list. A conjunctive phrasing for the state transition proposition would require stringing intermediate states in series.

- -

The empty symbol

- -

Turing described a clerk writing symbols into squares, with the option to erase them. He states, "In some of the configurations in which the scanned square is blank (i.e. bears no symbol) the machine writes down a new symbol on the scanned square: in other configurations it erases the scanned symbol."Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society, Series 2, Volume 42 (1936): 231. So the original paper uses blank to mean no symbol. Turing fairly consistently refers to "blanks" rather than to a symbol that represents a blank. However, thirty pages in, he does say this, "for in the complete configuration the symbols are all blanks"Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society, Series 2, Volume 42 (1936): 261..

- -

The more abstract concept here is that of a container. A piece of paper is a container for symbols. When it contains no symbols, the container is empty. Only when we say the container is a piece of paper does it make sense to call it blank. But we are speaking of abstractions, not of paper. The question is not one of blankness, rather it is the more abstract question of emptiness. When computation theory texts are translated into French, the blank symbol is called the "symbole vide", or literally "empty symbol". Hence, in the French context, paper as a container does not carry with it a distinct terminology. -

- -

So the actual question, which dates back to the very definition of the Turing Machine, is this: when a square from Turing's paper has not yet been written to, does it hold an empty symbol, or is it actually empty?

- -

As defined in texts such as Hopcroft and Ullman, a Turing Machine cannot function when tape cell does not read a symbol, because the next state function is defined such it must be given a symbol. If a cell were to be void of symbols the machine would break.

- -

Imagine a tape machine, called machine A, where, upon attempting to read an empty cell, the machine head instead returns a control symbol representing that the cell was empty. To accomplish this, the head would have to do some work, and it would have to be able to detect emptiness, and then chose to return the empty symbol instead of a read value. This feature would fix the problem of not having any defined next state behavior for an empty cell. Furthermore, suppose the inverse process was also special in that upon attempting to write the empty symbol, the machine takes action, and empties the cell out. This would facilitate an erase operation.

- -

Now imagine machine B, where a yet to be used cell on a tape directly holds the symbol. Because it is merely another symbol, reads and writes occur exactly as they do for other symbols.

- -

As long as the cost of the empty cell fix is constant time, the differences between machine A and machine B are computationally inconsequential. However, for machine A, the mathematician is greatly inconvenienced if he cares to write down the contents of the tape, as he will need some means of communicating that a tape cell is empty. As a mathematician is wont to do, he would probably invent a symbol to express this meaning. The cup, empty box, or null set symbol are all possible choices. - However, let us not lose sight of the level of analysis we are doing. We are discussing the computation theoretic Turing Machine, and doing so in the realm of forms. Given that our discussion is in the abstract, machines A and B are in fact the same, the only difference being that the description for machine A is less elegant. Thus, we will recognize that an empty tape, one that has not been written to, is full of empty symbols.

- -

Computational theorists often describe a two-step process. First, a Turing Machine writes a string to be studied onto a tape that was initially filled with all empty symbols, and second, the tape is moved to another Turing Machine who's purpose is to recognize a property of the string being studied. In this process, a tape is used as a communication medium, and it follows that communication theory can be applied to this messaging scenario. Messages sent on a channel must be formatted so they can be placed on the channel and later recovered. The specification for such structuring is called a communication protocol. The protocol implies a higher authority, as both the sender and the receiver must have knowledge of the same designed-in protocol. In a sense, a protocol is the meta-message sent before the message itself.

- -

The intention of placing the empty symbol in \Gamma but not in \Sigma appears to be that of making the empty symbol serve double duty. Firstly that of a default value for a cell that has never been written, and secondly as a structural component of a communications protocol. This protocol was designed by mathematicians with the intention of making it impossible for programmers to send studied string messages that can always be recovered by a receiving recognizer Turing Machine. In short, the empty symbol is also being used as an in-band EOT (end of transmission) symbol.

- -

However, if this is the intention, the protocol is flawed, because Turing Machines are bestowed with the ability to erase characters. An input machine could, for example, happily output an array of strings while using an arbitrary number of empty symbols to separate the elements of a variable length array. A receiving machine could then not know how many elements it should try to recover, or when to say a separator is sufficiently long that it isn't looking at a separator. Nothing in the Turing Machine definition prevents this.

- -

Furthermore, the Universal Turing Machine can act as the aforementioned higher authority. In this case, Turing Machines, and sometimes their tapes, are written to a Universal Turing Machine's tape. Consequently, it is not only possible to want to terminate multiple strings in series, as mentioned in the prior paragraph; the termination issue itself is embedded in proofs such as the Halting Problem.

- -

A common technique programmers use for embedding strings with terminators within other strings is to embed escape characters. This is another in-band protocol, and it is inefficient. The escape sequences grow exponentially with nesting levels. Also, such strings with embedded escape sequences cannot be interpreted without knowledge of the intended nesting level of the string author, which requires the interpreter of the string to know the author's intentions.

- -

For the modified computational Turing machine presented later in this chapter there will be a separate control alphabet, as for the Hopcroft Ullman interpretation. However, due to the reasons presented in this section, that alphabet will be part of the alphabet \Sigma rather than distinct from it. Programmers then must explicitly design communication protocols that suit the problem they are working on, and those protocols become opaque for examination by a higher authority.

- - -

The unspecified

- -

In the first edition of this book, I introduced a "no read until after write" rule while working towards an architectural Turing Machine so as to sideline the empty symbol, because real machines do not have them. This did not replace the need for a communication protocol for sending messages between machines, but it did make it possible to remove the empty symbol from programmed controller definitions.

- -

The standard 9-track tape introduced by IBM in 1964 came from the factory unformatted. The format operation would write a header and an EOF marker to mark the end of the device file. Then, a standard library call such as open(), followed by write(), would write over the EOF marker, continue writing data, and finally append a new EOF marker, essentially pushing the EOF boundary back. EOF could be pushed back until the physical EOT marker was struck. This matches, in some ways, how the empty symbol is used on the computation theoretic Turing Machine in the Hopcroft and Ullman book if we consider it to be an EOF marker. However, a difference exists in that the real machine would never use an EOF to erase data characters.

- -

While using the standard library to write tapes the empty part of the tape could not be read until after it was written, so early tape machines indeed enforced the "no read until after a write" rule. However, if the programmer were to seek the head back into the device file to do fresh work and perform reads and writes, the device EOF would be nowhere in sight. The burden of the "no read until after a write" rule would then fall on the shoulders of the programmer.

- -

Core memory, and later system memory, was random access and initially fully accessible. The data would be whatever scrambled mess the machine booted with, or in early virtual memory systems, whatever was left over from the prior use of the page. The approach of recycling pages was a security hazard, so today a page is initially allocated from a read-only zero page, and due to a copy-on-write trap, a new page will be created in memory then scrubbed with zeros. If the computational Turing Machine's empty symbol maps to a word of zeros, then the empty symbol remains a poor model, because generally the data message, say sent between the input writer and the recognizer receiver, will also contain many zeros. The advantage is that if a programmer attempts to dereference a zero pointer, a segmentation fault occurs. So in this system, the program is again burdened with maintaining the "no read until after a write" rule.

- -

A violation of "read only after a write" could be detected by a modified computation theoretic Turing Machine, if, instead of an empty symbol, the initial tape is filled with the unspecified symbol. The end objective is to detect an erroneous condition, which is useful for debugging and testing. Normally Turing Machine design does not concern itself with those design steps, as it is busy answering questions about known working programs. Though perhaps an algorithm could be studied for this very quality, of not ever making decisions based on unspecified data. Nor do real machines have an unspecified symbol, rather a program reads garbage from memory locations with unspecified data. However, there is some precedent with hardware simulators, which typically support an x, standing for 'unknown' logic value.

- -

Like empty symbol, unspecified is a meta symbol. It is describes the data, or lack thereof, rather than being the data. Specifically, the unspecified symbol says that there is a singular alphabet symbol at the memory location, but the machine is not being instructed as to which symbol it is. Because the Turing Machine state transition function requires being given specific symbol value, and a single symbol value is not specified, reading a unspecified would break the machine. Of course, that would be a bad thing, so some sort of modification to the Turing Machine definition is required for working with an unspecified symbol.

- -

The three reasons that data can be unspecified is because it was not was not initialized, that the history that lead up to it is unknown by the program doing the read, or that it was written from the output of a true random number generator. Technically, the output of a psuedo random number generator belongs in the 'unknown history' category. An example of purposefully ignoring history would be a program that reverse a string without looking at the values being reversed. A reverse string program need not be apprised of the value of the string being reversed, it need only be aware of the structure give to according to the protocol followed by the machine that wrote the string.

- -

Given the conventional Turing Machine definition it is not possible to write a string verse function that does not look at the value of the data being reversed. This is because the read of the value under the head is integrated into the machine definition, so it always happens, and it always gates the next state transition function.

- -

The TTCA computation theoretic Turing Machhine

- -

A goal of the computation theorist in defining a Turing Machine is to make the math concise and elegant as they can make it. This notation qualifies. However, the goal of the computer architect is to make an intuitive to design and test machine that performs well. Perhaps if a computer architect were to define the computational Turing Machine, this change in emphasis would favor a different definition.

- -

The following modifications will be made to the computation theoretic Turing Machine definition so as to support the unspecified symbol.

-
    -
  1. Move to a Moore style programmed state controller, so that actions can be managed separately from state transitions.
    2. -
  2. Among the new explicit actions, to have two read instructions, a state transition gating symbol read, and data symbol read, along with two variables to hold the read results.
    3. -
  3. To match the two read functions, the write function can specify which of the read buffer contents to put on the tape.
    4. -
  4. If uspecified -
- -

For ease of programming the new machine will have three layers of next state functions. First used is the state function that takes into account both the current state, and the control read value. If no next state is defined by it, then a second next state function is called, in this case, the current state is not an operand. This is for defining default arcs. If a next state is still not defined, then we move to a third next state function which is unconditional. This is the state the machine goes to if there is no next state specified and there is no default next state defined.

- -

For clarity of presentation purposes, the definition will be split into two parts, that which is programmable, and that which is fixed as part of the Turing Machine definition.

- -

There is a mechanical procedure for converting a Moore Machine into a Mealy Machine, and the reverse. Two such converted machines are equally expressive. Making read an explicit action, instead of having it implied by a state transition, increases the number of states in a controller, and consequently the numbers of steps that must be taken. However, the new machine can do in two steps, anything the former machine could do in one, consequently this change affects the multiplier constant on the linear term of the step count formula, but does not change the computation complexity class determined from such a step count. The three layers of next state functions are equivalent to one layer, where the missing arguments are filled in with all possible values. This potentially increases the number of state transition arcs that must be specified, but the state transition logic and the number of states remain unchanged. Giving the specification in two parts does not change the total specification. Hence, - these modifications are computationally inconsequential.

- -

The TTCA Turing Machine fixed part

- -

- MF = (QF, ΣF, AF, λF) -

- -

QF: The set of predefined states, including QF.\mathtt{initial} and QF.\mathtt{unspecified\_decision}.

- -

ΣF: The set of predefined symbols, including ΣF.\mathtt{unspecified} and ΣF.\mathtt{left\_of\_leftmost}.

- -

AF: The set of available actions {\mathtt{no\_op}, \mathtt{left}, \mathtt{right}, \mathtt{write\_\sigma}(\sigma), \mathtt{write\_d}, \mathtt{write\_g}}, where \mathit{symbol} must be in Σ.

- -

λF: The predefined action table. A set of pairs of the form \langle q_0, a \rangle, where q_0 is the current state, and a is a member of AF.

- - -

The TTCA Turing Machine variables

- - - MV = (q, d, g) - - -

q: is the current state of the machine. -

d: is the data register. -

g: is the gate register. - - -

The TTCA Turing Machine programmable part

- -

- MP = (QP, ΣP, λP, δ, δ_0, δ_00) -

- -

QP: A set of state symbols.

- -

ΣP: A set of data symbols. - -

λP: The programmed actions. A set of pairs of the form \langle q_0, a \rangle, where q_0 is the current state, and a is a member of AF.

- -

δ: A set of state transition triples, each triple is of the form <q_0, r.σ, q_1>. Where q_0 is matched the current state of the machine. r.σ is a symbol in register r. q_1 is the next state. q_0 and q_1 come for the total set Q. σ comes from the total set Σ. r is either d or g.

- -

δ_0: The default transition table. A set of state transition pairs, each pair is of the form <r.σ, q_1>. Where r.\sigma is a symbol found in the specified register, either d or g. q_1 will be taken as the next state.

- -

δ_00: A default next state.

- -

The TTCA Turing Machine in total

- -

- M = (Q, Σ, A, λ, δ, δ_0, δ_00) -

- +

By relying on the unconditional next state transition to handle payload characters, the controller logic remains perfectly static regardless of the size or complexity of the programmed alphabet ΣP. The programmer is freed from managing the data, allowing him to focus entirely on the structural organization of the algorithm.

The Turing Machine architecture/organization - - - +

If a computation requires a two way infinite tape, the single ended tape machine can emulate it by interleaving the addresses: assigning odd addressed cells to represent the right going half, and even addressed cells to represent the left going half. This emulation requires taking two steps instead of one to advance in a given logical direction. When analyzing the time complexity of an algorithm, this overhead merely doubles the constant on the linear term, leaving the asymptotic order of complexity entirely unchanged. The outcomes of decider programs are unaffected. Therefore, utilizing a single ended tape is an inconsequential variation of the two way tape machine.

@@ -3902,4 +3825,6 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos --> -->