Is interactive computation a superset of Turing computation?

Nick Thomas September 21, 2012

Abstract Modern computers interact with the external environment in complex ways for instance, they interact with human users via keyboards, mouses, monitors, etc., and with other computers via networking. Existing models of computation Turing machines, -calculus functions, etc. cannot model these behaviors completely. Some additional conceptual apparatus is required in order to model processes of interactive computation.

Introduction

It is generally believed that everything that computers do can be done by Turing machines. We believe that, for every task that a computer can carry out, we can write a Turing machine that does the same thing. Recently this belief has been challenged by proponents of the interactive paradigm of computing. They claim that there are a class of computations, called interactive computations, which computers can perform, but which Turing machines cannot perform. See, for example, Goldin and Wegner [2005], Goldin and Wegner [2008], Eberbach et al. [2004], van Leeuwen and Wiedermann [2001], Dodig-Crnkovic [2011], Smolka et al. [2006]. Interactive computations are computations which involve the computing device receiving input, and producing output, while in the middle of computation. The idea is that a Turing machine cannot perform these computations, because it can only receive input and produce output at the beginning and at the end of its computations. Recall that a Turing machines input is simply the contents of its tape when it starts running. Its output is simply the contents of its tape when it stops running. The concept of a Turing machine contains no provision for receiving input, or giving output, while in the middle of computation. It starts with its input, it performs its computation, and it ends with its output. This means that there are certain computer programs which Turing machines cannot implement. Goldin and Wegner [2008] give the example of a computer program designed to drive a car from one location to another. The program must 1

take input from the environment (the movements of other cars, the movements of pedestrians, trac signals, etc.) and respond to this input by giving instructions to the car to change its behavior in various ways (turning, accelerating, braking, etc.). This program, by its nature, requires taking input from the environment and giving output to the environment while in the middle of computation. A computer can implement this program; a Turing machine cannot. The reason that a Turing machine cannot implement this program is that a Turing machine cannot take new input while it is running. It must take all of its input at the start of computation, and produce all of its output at the end of computation. So in order to implement a driving program with a Turing machine, it would have to be the case that it was possible to supply all of the information about the environment before the computation began, run the computation, and then carry out all of the driving instructions after the computation was nished. But this is not possible, because what happens in the environment is dependent upon the instructions the computer gives to the car; so the environmental information at a given moment is unknown until the driving instructions of the previous moment have already been carried out. Other examples of programs like this are programs which interact with human users, robotics programs, and programs which dynamically interact with other programs over the Internet (e.g., web servers). The interactive view of computation says that all of these programs are examples of interactive computations, and that none of them can be implemented by Turing machines. Every behavior that Turing machines can implement can be thought of as computing a mathematical function. The behaviors of computers which Turing machines cannot implement are behaviors which cannot be thought of as computing a mathematical function. These behaviors involve interacting with processes outside the computation while the computation is running. Various formal models of interactive computation exist. These include the -calculus [Milner, 1999] and persistent Turing machines [Goldin, 2000, Goldin et al., 2004]. These models oer a rigorous way to talk about interactive computation. However, as we will see, we do not need to depart completely from existing computational paradigms in order to model interactive computation. It is sucient to augment existing models (e.g., Turing machines) with additional conceptual apparatus. We can reinterpret existing work on interactive computation in these terms.

1.1

Turing machines

Turing machines are a mathematical model which formalizes the concept of computation. They were invented by Alan Turing as a way of studying the mathematical properties of computers and things like computers. A Turing machine consists of a tape, a tape head, and a set of state transition rules. The tape is a series of squares, each of which may be blank, or contain a symbol. The tape is unbounded in length in one direction, to the right. The 2

tape head is located at a denite position on the tape at any given time, and it is capable of reading the symbol in the square it stands over, and writing a new symbol into that square. There is a set of states, representing steps in the algorithm the Turing machine executes. The states include one starting state, and one halting state. The state transition rules specify what the Turing machine may do in each state. A state transition rule says something of the form, if you are in state s and the symbol under the tape head is c, then transition to state t and perform this action. The action may be one of, move the tape head left, move the tape head right, or write the symbol d under the tape head. So a Turing machine is similar to a computer, except that it is extremely spartan in its basic design. Every Turing machine can be thought of as computing some mathematical function. We can think of the contents of the tape when the machine starts running as the input to the function; and we can think of the contents of the tape when the machine halts as the output of the function. If there exists a Turing machine which can compute any value of a given function in nite time, then that function is said to be Turing-computable. Most mathematical functions are Turing-computable, but it is known that there are some functions which are not. For instance, no Turing machine can solve the halting problem: that is, the problem of determining whether or not an arbitrary Turing machine, with an arbitrary input, will eventually halt. As another example, no Turing machine can compute the busy beaver function, discovered by Rad [1962]. The busy beaver function (n) is (roughly) o the largest number that can be written out by a Turing machine with n distinct states. It is clear that no Turing machine can compute the busy beaver function. Such a TM would need to have k states for some k, but it would output (k +1) when given k + 1 as input. However, by denition, the largest number it can possibly output is (k), leading to a contradiction. Let us nish by giving the set-theoretic denition of a Turing machine, as may be found, e.g., in Bridges [1994]. Denition 1.1.1. A Turing machine M = (K, , , s0 ) is:
A nite set K of states. A nite alphabet , including the blank symbol # and not including L or R. A transition function K (K {h}) ( {L, R}). s0 K is the initial state. h K is the halting state.

We describe the state of a Turing machine at a given time using a structure called a conguration. The conguration says what state the Turing machine

is in, what the contents of its tape are, and where the tape head is located on the tape. Denition 1.1.2. A conguration C = (s, w, n) of M is:
s K {h}, the state of M. w , the contents of Ms tape.1 n N, the position of Ms tape head.

Now we need to describe the way that the Turing machines conguration changes over time. We dene a relation C C , read C yields C , meaning that if the Turing machine is in conguration C, its next computational step will leave it conguration C . Denition 1.1.3. Let M be a Turing machine, and C, C two congurations of M: C = (s, w, n), C = (s , w , n ). Then C C i: (s, w[n], s , c) , c ; n = n + 1 if c = R, n = n 1 if c = L and n 1, n = n otherwise; w = w if c {L, R}, w = w[c n] otherwise.

The importance of Turing machines is that they are a general model of computation. Every computable function can be computed by a Turing machine. This fact is expressed in the Church-Turing thesis.

1.2

The Church-Turing thesis

The Church-Turing thesis sprang out of research into the concept of eective calculability. This was an informal, intuitively understood concept which mathematicians of the time worked with. It corresponds to our modern concept of computability. A function is said to be eectively calculable if there is some procedure (an eective method) to produce the values of the function, which a person can carry out in nite time, following a precisely and nitely describable set
1 Note

the use of the Kleene star. means, the set of all strings over symbols in .

of instructions, without requiring any insight or ingenuity on the part of the person. An example of an eective method is the technique of performing long division which is taught in elementary schools. Several individuals attempted to formalize the concept of eective calculability, by inventing mathematical formalisms in which, it was hoped, every eective method could be expressed. There were three such contemporaneous attempts:
Alan Turing invented Turing machines. Alonzo Church invented the -calculus. Alonzo Church, Stephen Kleene, and J.B. Rosser invented -recursive functions.

It was proven that all three of these models computed the same set of functions. Subsequent work involved designing many dierent models of computation in order to determine if any of these models had capabilities that surpassed those of Turing machines, the -calculus, and -recursive functions. In every case they were found to be equivalent. For example, it was found that non-deterministic Turing machines are equivalent to Turing machines [Lewis and Papadimitriou, 1981]. A non-deterministic Turing machine is like a Turing machine, except that at every step of computation, it is capable of splitting into multiple copies of itself which follow divergent computation paths. The fact that every model of computation computes the same set of functions is expressed in the Church-Turing thesis. The Church-Turing thesis (CT) states that every eectively calculable function can be computed by a Turing machine. It therefore follows that every eectively calculable function can also be computed by the -calculus, by recursive functions, by a non-deterministic Turing machine, etc. Thus, according to the CT, the notions of computability, eective calculability, and Turingcomputability are equivalent. A mathematical function is computable if and only if it is possible to write a Turing machine which computes it. Since the notions of computability and eective calculability have no formal, mathematical denitions, the CT is not a mathematical theorem, and it cannot be formally proven. Nonetheless, it is universally accepted by computer scientists, and it is one of the foundational ideas of the eld.

1.3

Interpretations of the Church-Turing thesis

The Church-Turing thesis, since it is an informal and imprecise claim, has various interpretations. A conservative interpretation, what Piccinini [2011] calls the Mathematical CT, is that every computable function can be computed by a Turing machine, and that all formalisms for specifying computable functions (the -calculus, -recursive functions, etc.) are equivalent to Turing machines.

The Church-Turing thesis can also be understood as having implications about the capabilities of physical systems. Piccinni denes the Modest Physical CT, which says that it is impossible to construct a physical system which can compute a non-Turing-computable function. Piccinini also denes the Bold Physical CT, which says, roughly, that the behavior of every physical system is Turing-computable. This would mean, for instance, that it would be possible to construct a Turing machine which computed everything about the future state of the universe, given complete information about the present state of the universe.2 Goldin and Wegner [2008] dene another interpretation of the CT, which they call the Strong Church-Turing Thesis (SCT). They describe the SCT as the claim that Turing-computation and computation are the same thing. Roughly, the idea is that everything that physically realizable computers do can be done by Turing machines. Goldin and Wegner claim that the SCT is false. In formulating this claim, they have interactive systems in mind. They want to say that computation is the same thing as interactive computation, and that Turing computation is a subset of interactive computation. They have in mind examples such as the program that drives a car, the program that interacts with a user via teletype, etc. Before examining Goldin and Wegners claim in more detail, we want to clarify the concept of an interactive system.

1.4

Interactive systems

An interactive system is a set of components, some or all of which are computer algorithms, which execute behaviors that involve communicating with each other. We follow Milner [1999] in referring to the components of interactive systems as processes. A process is a physical system which exchanges information with other processes. For our purposes it is either a computer, or something that can exchange information with a computer, such an I/O device or something that can interact with an I/O device. Thus, for instance, we can think of a computer keyboard as a process, and we can also think of a human typing at a computer keyboard as a process. Let us consider some real-world examples of interactive systems. Such systems include the Internet, cell phone networks, and concurrent software which involves multiple interacting threads. They also include cases in which a human user interacts with a computer; we consider the human to be one process, and the computer to be another process. We may also think of object-oriented programming as an interactive paradigm, by thinking of each object as a process, and saying that they interact with each other when they invoke each others methods.
2 There is a practical qualier to this line of thinking, which is that such a Turing machine would presumably be too large to t inside the universe. So this Turing machine can exist only in thought experiment, and not in reality.

Figure 1: An example of an interactive system, drawn abstractly. There are various mathematical models of interactive computation. The problem of formulating an ideal formal model of interactive computation is an interesting area of active research. Later we shall work with some such models: namely, persistent Turing machines and the -calculus. For now we shall discuss interactive computation in an informal fashion. We can draw an interactive system in a diagram such as Figure 1. Each node represents a process, and each arrow represents a point of communication between two processes, with information being sent in the direction of the arrow. Each process has its own internal state, which it updates periodically. Furthermore, each process periodically sends and receives information along its communication channels. (We do not specify, in this informal introduction, the precise nature of this communication. For instance, we do not specify whether it is synchronous or asynchronous.) We can consider two types of processes: computable processes, and noncomputable proceses.3 Intuitively, a computable process is one whose behavior can be simulated by a Turing machine; and a non-computable process is one whose behavior cannot be simulated by a Turing machine. A computable process could represent a computer or a computer program. A non-computable process could represent something such as a human user or an instrument for interacting with the outside environment. (For example, in the car-driving program, we could have a non-computable process representing the video camera which monitors the road.) If a process is computable, then there is some Turing machine which takes as input the internal state of the process and the contents of its input channels at a given moment, and produces as output the internal state of the process and the contents of its output channels at the next moment. If a process is
3 We do not assume the Bold Physical CT, under which there are no non-computable processes.

non-computable, then there is no such Turing machine. Various formal models of interactive systems exist. Let us now turn to one such model: the persistent Turing machine, or PTM.

1.5

Persistent Turing machines

A persistent Turing machine (PTM) is a modication of a Turing machine designed for modeling interactive computation. It is a non-deterministic three-tape Turing machine (N3TM) with a read-only input tape, a read-write work tape, and a write-only output tape. A PTM is non-deterministic. What this means is that, at every step in computation, it may branch into multiple copies of itself, which follow dierent computation paths. (One may notice the similarity to quantum non-determinism.) Note carefully that nobody thinks that PTMs non-determinism makes them more powerful than Turing machines; non-deterministic Turing machines are Turing-equivalent. The PTM goes through a series of cycles, called macrosteps. In each macrostep, it gets an input string from the environment, performs a computation, and supplies an output string to the environment, in that order. In each macrostep, it starts with the work tape contents that were present at the end of the last macrostep: so we say that the work tape is persistent across macrosteps. We can model an interactive system as a set of PTMs strung together in a sequence. For instance, maybe we have PTMs called A, B, and C. The output of A becomes the input of B, and the output of B becomes the input of C. One shortcoming of PTMs is that they can only easily model interactive systems in which all of the processes are chained together in a sequence like this. They could not, for instance, model the system drawn in Figure 1, because some of the processes have multiple inputs and multiple outputs. So we say that PTMs model sequential interaction, rather than interaction in general. See Subsection 2.1 for the formal denition of a PTM. It is important to note that a PTM is simply an N3TM, interpreted in a certain way. The set-theoretic denition of a PTM is is the set-theoretic denition of an N3TM. The denition of an N3TM, in turn, is a simple variation on the denition of a Turing machine given in Section 2.1. The only dierences are that there are three tapes, and is one-to-many, rather than one-to-one, capturing the idea that the N3TM is non-deterministic. (We call it a transition relation, rather than a transition function.) The dierence between an N3TM and a PTM is that we go on to make some informal statements about how that set-theoretic denition is to be interpreted. We say that the rst tape is a read-only input tape, the second tape is a read-write work tape, and the third tape is a write-only output tape. Then we say that the PTM goes through a series of macrosteps, in each of which it receives input, performs a computation, and produces output.

1.6

Is interactive computation a superset of Turing computation?

Let us scrutinize the claim that interactive computation is a superset of Turing computation. Goldin and Wegner [2008] say that a certain interpretation of the Church-Turing thesis, which they call the Strong Church-Turing Thesis, is false, because Turing machines cannot model interactive systems. Are they correct in saying this? Goldin and Wegner argue that certain real-world computer systems (e.g., a car-driving program) cannot be implemented by a Turing machine. They claim, furthermore, that they have formally proven that the SCT is false (see page 29 of Goldin and Wegner [2008]). However, they give only a vague sketch of such a proof; and we can see on independent grounds that there cannot be such a proof. The Church-Turing thesis is not a formal claim of pure mathematics; for this reason, there is no formal proof of the Church-Turing thesis. The same is true of the SCT. There cannot be a formal proof that the SCT is true or false, because it is not a formal claim. In asking whether the SCT is true or false, we need to realize that what we are asking is not a mathematical question. It is more of a philosophical question. Goldin and Wegner argue that PTMs can model systems that Turing machines cannot model, and that the SCT is therefore false. One important question to ask here is, are PTMs actually a dierent thing from Turing machines? I suggest that PTMs are actually a kind of Turing machine. If we we say PTMs and Turing machines are dierent things, how are we to ascribe meaning to that statement? It cannot mean, a (K, , , s0 ) is not a (K, , , s0 ), because that is false. But if that is not what it means, then I dont know what it means. Informally, we think of a PTM as having a read-only input tape, a read-write work tape, and a write-only output tape. We think of it as being something which can interact with other processes. But why cant I think of an N3TM as having those properties? Is a PTM anything other than an N3TM which I think of as having those properties? Formally speaking, the dierence between a PTM and an N3TM is that a PTM is a Turing machine which has been augmented with the concept of macrosteps. We say that a PTM goes through a series of macrosteps, through which a work tape persists; whereas we do not say this of an N3TM. But instead of saying, PTMs go through a series of macrosteps, whereas N3TMs do not, couldnt I say, N3TMs sometimes go through a series of macrosteps, and sometimes do not? Does the content of those two statements dier in any way? If so, what is the dierence? This is clearer if we substitute the terms PTM and N3TM with their set-theoretic denitions. Then the rst statement becomes, a (K, , , s0 ) goes through a series of macrosteps, whereas a (K, , , s0 ) does not. The second statement becomes, a (K, , , s0 ) sometimes goes through a series of macrosteps, and sometimes does not. 9

We could throw out the word PTM entirely without losing any expressive power. I could just replace every instance of PTM with N3TM with macrosteps, and I wouldnt be saying anything dierent. For instance, let us re-write the statement, PTMs can model interactive systems, whereas Turing machines cannot. This statement becomes, when N3TMs are augmented with the concept of macrosteps, they can model interactive systems, and otherwise they cannot. Incidentally, we can take the second statement as a claried version of, the SCT is false. It seems to be true that Turing machines cannot model interactive systems without invoking some additional concepts; and this captures the thrust of Goldin and Wegners argument. (We say, some additional concepts, rather than the concept of macrosteps, for the following reason. Turing machines plus macrosteps cannot model all interactive systems; they can only model sequentially interactive systems. So it is not clear that macrosteps are the right concept with which to augment Turing machines. But I think that it is clear that some conceptual augmentation is required for Turing machines to model interactive systems.) Let us take this as our working formulation of the SCT: Turing machines can model interactive systems without invoking any additional concepts. (Later we shall consider other, non-equivalent formulations.) Now we may ask: is the SCT true or false? We have already pointed out that the SCT is not a claim of pure mathematics. There cannot be a formal proof that it is true or false, because it cannot even be stated formally. The SCT, besides not being a mathematical claim, is also not an empirical claim. There is no scientic experiment we could perform which would determine whether the SCT is true or false. It would seem, then, that we are not likely to be able to rigorously prove or falsify the SCT. We cannot expect to meet the scientists or the mathematicians standard of proof. We may at best hope for the philosophers standard of proof. Before addressing this issue in further detail, it is worth reecting on the most mysterious word in our formulation of the SCT: that is, the word model. What does it mean for a mathematical formalism such as a Turing machine or a Turing machine with macrosteps to be a model of a physical system? Let us consider an example. I can write a computer program a Perl program, let us say which prints out a list of the rst 1,000 prime numbers. I can also design a Turing machine which does the same thing. We say that the Turing machine is a model of the Perl program. There are many dierences between the Turing machine and the Perl program. The Turing machine is not written in Perl. They may dier in many details of the algorithm they use. The Perl program may write its output to a le, or to a teletype interface; whereas the Turing machine writes its output to its output tape. A Perl program does not have a set of tapes; it does not have a read-write head; it does not have a table of transition rules. But still we say that the 10

Turing machine is a model of the Perl program. There must be some relevant similarity between a model and the thing it models. In this case the similarity is just this: that the Turing machine and the Perl program compute the same function. It is this sort of similarity that we are talking about when we say that a PTM is a model of a car-driving program. The similarity is not that they are computing the same function, because neither one of them computes a function. But in some sense, they have the same behavior. If the car-driving program produces a given output from a given input and internal state, then the PTM produces the same output from the same input and internal state. That is one way of describing the similarity. What does it mean for something to model something else? We speak, for example, of a scale model of a building: a little construction of wood, glue, and paint which captures the general features of a real or planned building. We also say that Newtonian physics models the behavior of the physical world, within certain restrictions of scale, speed, etc. This is closer to the meaning we are discussing. In this context, by model we specically mean a mathematical formalism which captures some salient features of certain physically existing things. In order to call something a model, we might want it to say everything that can be said about the thing modeled. For example, perhaps a physicist could say what properties one would have to enumerate, for a particular atom, in order to have exhaustively described that atom. But something can also be a model without being an exhaustive description. Generally when we model physical objects, we do not model everything about them. For instance, a description of a baseball in the language of Newtonian physics probably does not mention the color of the stitches on the ball, or whether or it had previously been thrown by a famous baseball player. It may mention nothing more than the mass and position. And yet we still call this a model of the baseball. So a model does not have to be an exhaustive description of a physical object; it can be something which merely captures some salient features of the object. And it is in this sense in which our Turing machine that computes prime numbers is a model of the Perl program that computes prime numbers. The salient feature that the Turing machine captures is the function that the Perl program computes. Now let us try to stretch our understanding of the word model. Suppose I nd a strange snake in the wilderness which has red, green, and blue scales, arranged in a complex pattern on its back. Suppose, furthermore, that I nd an algorithm which predicts the pattern, and I write a Turing machine (T) which computes that algorithm. Uncontroversially, we say that T models the pattern of the snakes scales. Suppose, however, that T does not output the correct pattern. Suppose, furthermore, that I can write another Turing machine (U) which takes Ts output, and processes it to produce the correct pattern. We would probably say that T and U together form a (somewhat awkward) model of the pattern of the 11

snakes scales. But, here is a hard question: is T by itself a model of the pattern of the snakes scales? On the one hand, we can say that it is, because T contains the desired information, in a coded, implicit form, which can be extracted with the appropriate method. On the other hand, we can say that it is not, because the relationship is too indirect. What I would like to illustrate with this dilemma is that model has no precise meaning. It is a concept with fuzzy boundaries. In the gray area between model and not a model, there are things which are neither clearly models, nor clearly not models. I would say that T is sort of a model of the snakes scales, and I do not think we will get anywhere in trying to give a hard yes or no answer to the question of whether or not it is a model of the snakes scales. Now let us return to our question: is interactive computation a superset of Turing computation? Is the SCT true or false? As I have already stated, I think that we can re-formulate this question as: can Turing machines model interactive systems without invoking any additional concepts? By interactive systems we mean physically realized computing systems which interact with their environment while running: the car-driving program, a program interacting with a human user, etc. We want to know whether or not Turing machines can model these systems. As I said before, we cannot resolve this question either with a formal proof, or by the scientic method. So it is not entirely clear how it is to be resolved. Nonetheless, I think that it has a fairly clear answer. I think that the SCT is false; that Turing machines cannot model interactive systems without invoking additional concepts. Let us briey reiterate the argument. A Turing machine cannot accept new input while it is running. This implies, in particular, that a Turing machines input cannot have causal dependencies upon its output. I see no way around these problems that doesnt involve introducing the concept of macrosteps, or something analogous. Having stated what I think is a true interpretation of the SCT is false, I will now state what I think are false interpretations of that claim. First of all, I take issue with the statement, PTMs can model interactive systems, whereas Turing machines cannot. I am inclined to re-write it as, a (K, , , s0 ) can model interactive systems, whereas a (K, , , s0 ) cannot. If that is what the statement means, then it is false; and if that is not what the statement means, then I dont know what it means. Another interpretation of the SCT is false would be, interactive systems can compute non-Turing-computable functions. Is this true or false? Theorem 2.4.10 will show that there is a timeless simulation of every sequentially interactive system. In other words, given any sequence of PTMs strung together, and a sequence of input tape states to be given to that sequence of PTMs, there exists a Turing machine which will compute the series of output tape states that the sequence of PTMs produces. This would seem to demonstrate that (sequentially) interactive systems cannot compute non-Turing-computable functions. But it doesnt quite do that, 12

for the following reason. If a sequentially interactive system contains noncomputable processes, then the simulating Turing machine does not say what those non-computable processes do; it only gives the set of possible things that those non-computable processes could do. The simulating Turing machine cannot say what the non-computable processes actually do, but only what they might do. So, suppose that we construct an interactive system which contains a noncomputable process that can compute a non-computable function. For instance, suppose that we have a PTM interacting with a magical oracle which can solve the halting problem. The PTM is programmed to take a Turing machine as input, give the Turing machine to the oracle, receive the oracles answer concerning whether or not the Turing machine halts on all inputs, and then give us that answer. We would say that this interactive system computes a non-Turing-computable function. But there are limitations to the signicance of this point. First, we have no reason to believe that such an oracle actually physically exists in our universe; so this interactive system exists for us only in thought experiment. Second, the PTM in this thought experiment is not, so to speak, doing the heavy lifting of actually computing a non-computable function; it just passes the job on to the oracle and then reports the oracles ndings. Third, this is not a new thought experiment. The oracle Turing machine idea has been around since Turing Turing [1939]; and the interactive paradigm doesnt really add anything new to the thought experiment. The essential point is that we cant actually build an interactive system which computes a non-Turing-computable function. Suppose one went up to the CEO of a hardware company and said, hey, interactive systems can compute nonTuring-computable functions; you should invest in researching them. The CEO would be excited to hear about this powerful new technology. But you would need to add, oh, sorry boss, none of the interactive systems we can actually build can do that. After hearing that he wouldnt be so excited. Goldin and Wegner do not seem to be claiming that interactive systems can compute non-Turing-computable functions. So the interactive thesis is false because interactive systems cant compute non-Turing-computable functions is a strawman argument. That said, it would be easy to misinterpret Goldin and Wegner as claiming that interactive systems can compute non-Turing-computable functions. From Cockshott and Michaelson [2007], it looks like such a miscommunication has already occurred at least once in the literature. I expect this particular miscommunication to continue to occur in the future. People have a mental habit of equating the topic of the limitations of Turing machines with the topic of Turing-computable functions. Our question concerning interactive systems is one of the few places in which it isnt correct to equate the two topics.

13

1.7

Implications

Why should we care whether or not interactive computation is a superset of Turing computation? Firstly, Goldin and Wegners ndings point out a certain deciency in the common understanding of the Church-Turing thesis. Computer scientists would typically say that every physically realized computational process can be modeled as a Turing machine. We have seen that this is not quite correct. Secondly, the interactive paradigm in general is a useful one. Our formal models of computation were designed in the early days of computing. Computers were things that solved math problems in batch mode. At this time, our models of computation corresponded in a natural way to real computers. Computers have since changed. They are no longer things that solve math problems in batch mode. They are things that do a vast panopoly of tasks; and these tasks usually involve dynamic interaction with people and the physical world. Models of interactive computation are a more natural way of modeling modern computers. They are a map with a tidier correspondence to the territory. It is not really accurate, however, to say that interactive systems constitute a form of super-Turing computation. Interactive systems cannot compute nonTuring-computable functions. So I would consider the phrase to be a misleading one.

Persistent Turing Machines

Now we shall consider some formal properties of PTMs, which are relevant to the question of whether or not interactive computation is a superset of Turing computation. A persistent Turing machine, or PTM, is a minimal modication of a Turing machine which lets it act as a process in an interactive system. A PTM is a non-deterministic three-tape Turing machine (N3TM). One of its tapes is a read-only input tape, one of its tapes is a read-write work tape, and one of its tapes is a write-only output tape. It goes through a series of macrosteps, each of which is a single halting Turing machine computation, that begins in the starting state and ends in the halting state. In every macrostep, it is assumed that the PTM begins having received a string on its input tape from some external input source. It performs computations which leave a string on its output tape, and it is assumed that that string is given to some external output sink once the PTM is nished computing this macrostep. Furthermore, the PTMs work tape state is preserved between macrosteps; thus, the work tape state at the start of a given macrostep is the work tape state at the end of the previous macrostep. This is an important property, because it lets the PTM remember what happened before this macrostep, in whatever way is computationally important.

14

Why are PTMs non-deterministic? They dont need to be. The interactivity of PTMs doesnt depend on their non-determinism. Nobody is trying to claim that the non-determinism of PTMs lets them do anything that ordinary TMs cant do. Non-deterministic TMs are Turing-equivalent. PTMs could have been dened as deterministic, and we would still be saying most of the same things about them. The non-determinism has the following advantage. With it, we can model non-deterministic processes in the real world. For instance, suppose we have a process which is an instrument that reads the state of a quantum system say, a digital geiger counter. Because the geiger counters behavior is unpredictable, we cant write a deterministic PTM to model the geiger counter. What algorithm would the PTM implement? We can model the geiger counter as a non-deterministic PTM. Instead of writing an algorithm which says what output the geiger counter produces, we can write an algorithm which non-deterministically branches into all of the possible output states that the geiger counter could have. This gives us a provisional sort of model that we can use to talk about the geiger counter. Now we shall review the formal denition of PTMs, and explore some of their mathematical properties which are relevant to our question.

2.1

Denition of persistent Turing machines

We repeat the denition of persistent Turing machines, as it is given by Goldin et al. [2004]. See that paper for further details. Persistent Turing machines are a modication of nondeterministic three-tape Turing machines (N3TMs). Hence, we begin with the denition of N3TMs. Denition 2.1.1 A nondeterministic three-tape Turing machine (N3TM) M = (K, , , s0 ) is:
A nite set K of states. A nite alphabet , including the blank symbol # and not including L or R. A transition relation K (K {h}) ( {L, R}) ( {L, R}) ( {L, R}). s0 K is the initial state. h K is the halting state.

An N3TM is deterministic (a D3TM) i is a function K (K {h}) ( {L, R}) ( {L, R}) ( {L, R}). The N3TM is equipped with three unbounded tapes. Each tape is divided into a series of cells, each of which holds a string of symbols from . Each tape has a tape head which, at any given time, is over a particular cell. The conguration of the N3TM at any given time is described by giving its state, the contents of its tapes, and the locations of its tape heads. Formally: 15

Denition 2.1.2 A conguration C = (s, w1 , w2 , w3 , n1 , n2 , n3 ) of M is:

s (K h), the state of M. w1 , w2 , w3 , the contents of Ms tapes. n2 , n2 , n3 N, the positions of Ms tape heads.

The transition relation describes how the conguration of the N3TM evolves over time. Each transition is called, in Goldin et. al.s terminology, a microstep. The N3TM evolves according to the following process. Suppose that the N3TM is in state s, and the symbols on its tapes are a, b, and c. Find all rules (s, a, b, c, s , a , b , c ) . If there are multiple such rules, then the N3TM splits into multiple copies of itself, each of which follows one of the available rules. In the new conguration for a given copy, the N3TMs state is s . If s = h, then the N3TM halts. If a = L, then the rst tapes head moves one cell to the left. If a = R, then the rst tapes head moves one cell to the right. Otherwise, the symbol in the current cell becomes a . The same rule applies to b and the second tape, and to c and the third tape. Formally: M: Denition 2.1.3 Let M be an N3TM and C, C be two congurations of
C = (s, w1 , w2 , w3 , n1 , n2 , n3 ), C = (s , w1 , w2 , w3 , n , n , n ). 1 2 3

Then C

C , i.e. C yields C in one microstep, i, for i = 1, 2, 3: (s, w1 [n1 ], w2 [n2 ], w3 [n3 ], s , c1 , c2 , c3 ) . n = ni + 1 if ci = R; i n i = ni 1 if ci = L and ni 1; n = ni otherwise. i
wi = wi if ci = L or ci = R; wi = wi [ci ni ] otherwise.

If M is a D3TM, then for every conguration C there is at most one solution C to the relation C C , because is a function. It will also be useful to dene a microsequence, i.e., a series of microsteps: Denition 2.1.4 Let M be an N3TM and C, C two congurations of M. We say that C C i there exist congurations C0 , ..., Cn for some n 0 such that C = C0 , C = Cn , and Ci Ci+1 for all 0 i n. is the transitive closure of . This completes our denition of N3TMs. Now we proceed to PTMs. 16

A persistent Turing machine is an N3TM in which the rst tape is considered to be a read-only input tape, the second tape is considered to be a read-write work tape, and the third tape is considered to be a write-only output tape. The PTM goes through an unbounded series of macrosteps, each of which consists of a series of microsteps terminating in the halting state h. Each macrostep begins with the PTM having been provided with the contents wi of its input tape, which we suppose to have come from some other process. It ends with the PTM having produced the contents wo of its output tape, which we suppose to be passed on to some other process. Throughout the series of macrosteps, the contents of the PTMs work tape are preserved (hence the term persistent), with the contents of the work tape at the end of one macrostep being the contents of the work tape at the beginning of the next macrostep. When P is a PTM, w
wi wo P

w means that when P starts running with work

tape w and input tape wi , it halts with work tape w and output tape wo . Formally: Denition 2.1.6 Let M be a PTM, its alphabet, and wi , w, w , wo . Then w
wi wo M

w , i.e. w yields w in one macrostep, i, for some s, ni , n , with i (s, wi , w, , n1 , n2 , n3 ) (h, wi , w , wo , n , n , n ). 1 2 3

i = 1, 2, 3:

( denotes the empty tape.) Note that if M is deterministic, then for every w, wi , then there is at most one solution wo , w to the relation w
wi wo M

w .

That completes our description of persistent Turing machines.

2.2

Sequential interaction

PTMs formalize the notion of sequential interaction. Sequential interaction is a subset of interaction in general, in which every process receives input from at most one process, and gives output to at most one process. Since sequential interaction is only a subset of general interaction, results about sequential interaction do not necessarily extend to general interaction. But it is not straightforward to extend PTMs to capture general interaction. So we shall content ourselves, in studying PTMs, with studying sequential interaction. We will later nd that many of the conclusions that we draw about sequential interaction do in fact extend to general interaction. Let us clarify the notion of a sequentially interactive system. We have some number of processes, and they are chained together, with the output of one process being the input to the next. We will postulate that the number of processes is nite. This is because we are interested in physically realizable systems, and an innite chain of processes is not physically realizable. 17

We will also postulate that the rst process takes input from some unspecied outside source, and the last process gives output to an unspecied outside source. We therefore dene sequentially interactive systems, or SISs. Denition 2.2.1 A sequentially interactive system (SIS) S = (P, ) is:
A nite sequence P [1, n] {the set of PTMs}, of processes. A nite alphabet , where we require that every process has as its alphabet.

In order for the PTMs to communicate with each other, they must have the same alphabet. It would be possible to arrange aairs so that the PTMs had a common alphabet for communication, but used dierent alphabets internally; or, to arrange aairs so that each connection used a single alphabet, but dierent connections had dierent alphabets. For simplicity, however, we restrict all PTMs in a given system to using a single common alphabet. Now we must describe the behavior of SISs: that is, the manner in which they map inputs to outputs. We do this by extending the yields in one macrostep ( ) operator of Goldin et al. [2004] to work with SISs. Instead of speaking of the macrosteps of a single PTM, we now speak of the macrosteps of a SIS. wi wo When P is a PTM, w w means that when P starts running with work
P

tape w and input tape wi , it halts with work tape w and output tape wo . When S is an SIS, we write W
wi wo S

W , where W and W are sequences

of tape states, with one tape state per PTM in S. The elements of W are the starting work tape states, and the elements of W are the ending work tape states. wi is the input to the system, and the input to the initial PTM. wo is the output of the system, and the output of the nal PTM. We also use a sequence of tape states, W i , which represents the series of intermediate outputs that the system produces. The rst element of W i is the input to S (i.e., wi ), and the remaining elements of W i are algorithmically generated, with a non-initial element of W i being the output of one PTM and i the input to the next PTM. So, for example, the rst PTM takes as input W1 , i i and produces as output W2 . The second PTM takes as input W2 , and produces i as output W3 ; and so forth. Denition 2.2.3 Let S = (P, ) be an SIS. Let p be the length of P . Let W, W [1, p] be sequences over , and wi , wo . Then W yields W in one macrostep, i.e.: W
wi wo S

i if and only if there exists a W i [1, p] such that W1 = wi and:

18

W1 W2

i i W1 W2

P1

W1 and W2 and

i i W2 W3

P2

Wp

i Wp wo

Pp

Wp .

The rst clause in the biconditional characterizes the behavior of the sequentially interactive system. The second clause, consisting of a series of conjunctions, characterizes the corresponding behavior of the PTMs that make up the system. This series of conditions can be read as, each PTM, starting in the initial work tape state belonging to it, with the input tape contents belonging to it, yields in one macrostep the input to the next PTM (or the output of the system, if it is the nal PTM), and ends in the nal work tape state belonging to it. For example, suppose that the SIS is a video decoder. Video decoders often consist of a set of algorithms which are applied in series: the rst algorithms output is the input to the second algorithm, the second algorithms output is the input to the third algorithm, etc. Consider a video decoder consisting of three algorithms; call them A, B, and C. The above series of conditions would be read, A takes the starting input i i i wi = W1 and yields as output W2 . B takes the input W2 and yields as output i i W3 . C takes the input W3 and yields as output wo .

2.3

Modeling physical processes

We can take the mathematical abstractions of PTMs and SISs as representing processes in the physical world. Physical systems which alternate between receiving input data, and giving output data, can be modeled as PTMs. Groups of such processes, sequentially interacting with each other, can be modeled as SISs. For instance, we can model the driving home from work example, or a human interacting with a computer terminal, or a streaming video decoder, as SISs. We shall model non-computable processes by taking nondeterminism as representing non-computable behavior. For instance, suppose we have a random number generator, which outputs a series of numbers between 1 and 4, using a source of quantum nondeterminism in order to select the numbers. We can model this system using a PTM which implements the following algorithm (for one macrostep): Algorithm 2.3.1. 1. Branch into four computation paths. 19

2. In one of these paths, write 1 to the output tape. In one of these paths, write 2. In one of these paths, write 3. In one of these paths, write 4. 3. Halt. The model species a set of possible nal tape contents (specically nal work tape and output tape contents, since the input tape is constant). The actual system yields one of the possibilities in this set, such that no Turing machine can predict which of the possibilities is actually selected, no matter how much information it is given about the state of the system at the beginning of the macrostep. This is how we choose to model the behavior of non-computable processes. As a further example, we can model the behavior of a human user typing at a keyboard by writing a PTM which branches into paths that output every possible string to the output tape. If the string lengths are unbounded then there will be an innite number of halting congurations, and the PTM as a whole will never halt; but this is not problematic. Of course, this PTM will be an idealization of the actual physically realized system, because the physical system will at some point reach a limit to the length of its strings. These PTMs are an idealization of the actual systems in a further way, which is that they do not capture the statistical properties of the systems in question. For instance, it may be that the quantum random number generator is twice as likely to output a 2 as it is to output a 1; but our model does not capture this fact. Similarly, our model does not capture the fact that a human is more likely to type certain things (e.g., coherent sentences or computer commands) than they are to type other things (e.g., random gibberish). In short, our model species only what behavior is possible, without specifying what behavior is probable. A Turing machine, as we will see in Subsection 2.4, can compute the set of possible behaviors which a non-computable process may exhibit. But a Turing machine cannot determine which behavior the physically realized noncomputable process actually exhibits. It cannot determine which number the quantum random number generator actually outputs, or which string the human user actually types. So the behavior of these physically realized non-computable processes is, unsurprisingly, not Turing computable. Now we will specify more precisely the behavior of the physical system that a sequentially interactive system models. Specication 2.3.2. Given an SIS S = (P, ), we say that S models a given physically realized system i, for every process in the physical system corresponding to a process Pn in P , during any given execution of the systems algorithm:
The physical process alternates between taking input data, and giving output data. A cycle of taking one unit of input data and giving one unit of output data corresponds to one macrostep of Pn . Call the physical

20

process correspoding to a macrostep, a physical macrostep. Number the macrosteps and corresponding physical macrosteps as 1, 2, 3, etc.
For every m, the process of computing the physical macrostep m temporally precedes the process of computing the physical macrostep m + 1. The physical process of computing macrostep m temporally follows the physical process of receiving input data for macrostep m, and temporally precedes the physical process of giving output data for macrostep m. If Pn is not the last process (i.e., n is not the length of P ), then for every m, the process of computing the physical macrostep m of Pn temporally precedes the process of computing the physical macrostep m of Pn+1 . The physical processs input/output behavior follows the rules specied by Pn . In every macrostep, it gives one of the outputs which is possible given its current input data and the contents of Pn s work tape at the beginning of the macrostep. In macrostep 1, the physical process behaves as if Pn s work tape is empty. In subsequent macrosteps, the physical process behaves as if Pn s work tape is in the state which resulted from the previous macrostep. This state will be one of the states which is possible according to Pn . (Just as one macrostep may yield multiple possible output tape states, it also may yield multiple possible nal work tape states. We nondeterministically select one of the nal work tape states associated with the output tape state that actualy occurred, as being the nal work tape state which actually occurred.)

2.4

Computing the behavior of sequentially interactive systems

The behavior of PTMs and sequentially interactive systems is Turing-computable in the following sense. Given a PTM or SIS, we can construct a computable function which takes as input a series of inputs to be given to the PTM/SIS, and produces as ouptut the series of outputs which the PTM/SIS yields from that series of inputs. We have already pointed out that a PTM/SIS in a certain sense cannot be emulated by a Turing machine, because a Turing machine cannot accept new input while it is running. So in a certain sense PTMs/SISs are a more expressive model than Turing machines. Now we wish to point out that in another sense PTMs/SISs are only as expressive as Turing machines. If a Turing machine is given as input a whole series of inputs to be given to a PTM over a series of macrosteps, it can produce as output the series of outputs that that PTM/SIS would produce from those inputs, over the same series of macrosteps. 21

Hereafter shall restrict our attention to SISs, because we can consider a PTM as an SIS consisting of one PTM. Given an SIS S, we dene the behavior relation of S as a relation over sequences of strings, ( ) ([1, n] )2 : i1 , ..., in i
i1 o 1 S i2 o 2 S

o1 , ..., on W1 , W2 , Wn , (1)

W1

Wn1

in on S

for some W1 , ..., Wn , where the Wi are sequence of work tape states. In the deterministic case, the behavior relation is actually a behavior function. Just as we speak of Turing machines computing functions, we may speak of nondeterministic Turing machines computing relations. We say that an NTM computes a relation R just in case the NTM produces the input o from the output i i iRo. And, using that notion, we may speak of a relation being computable or not. With all that, now we wish to say that the behavior of relation of every SIS is computable. Theorem 1. Let S be an SIS, and its behavior relation. is computable. Proof. It is sucient to construct an NTM which computes . We shall sketch how that could be done. First, notice that a single macrostep of the execution of a PTM is computable. That is, given an input tape and initial work tape, we can compute the resulting (set of) output tape(s) and nal work tape(s). This is a trivial consequence of the fact that PTMs are NTMs and one macrostep of a PTMs execution is a complete execution for the PTM-considered-as-an-NTM. Suppose S consists of PTMs P1 , ..., Pn . Computing a macrostep of S with input i consists of computing a macrostep of P1 with input i, letting its output be the input to P2 and computing a macrostep of P2 , and so forth until the output of Pn1 is the input to Pn and the output of Pn is the output of the system S. Suppose that the initial work tape state sequence was W , so that Wi was the initial work tape state for Pi . Then we are left with some W , where Wi was the nal work tape state for Pi . Clearly, given that a macrostep of Pi is always computable, this whole process is computable. So we can compute a macrostep of S. Next we note that computing the behavior relation consists of computing a series of macrosteps of S, with the input being given in each case, and the initial work tape state sequence being the nal work tape state sequence of the previous macrostep. Since this procedure is a simple iteration of a computable procedure, it is itself computable. That is, is computable.

22

2.5

Discussion

We noted in Section 1 that Turing machines cannot emulate the behavior of PTMs, because they cannot accept new input while they are running. The same is true with respect to Turing machines and SISs. We also noted that every SIS (and therefore every PTM, considering PTMs as the limiting case of SISs with one PTM) has a computable behavior relation. That is, given a sequence of inputs for an SIS, we can compute the sequence(s) of outputs which that SIS would produce from those inputs. These two results make contrasting statements about the relative expressiveness of Turing machines and PTMs as models of computation. There is no logical contradiction; but it is not immediately clear how to interpret the results. The key point to be made, I think, is that an NTM that computes a PTMs behavior relation is not, in a semantic sense, a model of the process that the PTM models. The information it provides is similar; but it is not a mechanism for thinking about an interactive system, because it lacks the notion of dynamic receptivity.

The -Calculus

The -calculus is a model of interactive computation. It is more general than PTMs, because it can capture non-sequential interactions, and interactions in which processes and process connections dynamically come into and go out of existence. The latter capabilities are called mobility. The -calculus is of interest to us because we have drawn various conclusions about interactive systems by studying PTMs, and we want to see that these conclusions extend to a more general model of interactive computation. In particular, we want to see that Turing machines can simulate the behaviors of non-sequential, mobile interactive systems. The basic concept in the -calculus is that of a process. Processes are abstract objects which can send messages to, and receive messages from, each other. Processes are dened recursively; all but the simplest processes consist of collections of concurrent, communicating processes. Processes communicate through named ports. If one process wants to send along a port of a given name, and another process wants to receive along a port of a given name, then a reaction can occur between the two processes, in which the rst process sends information to the second process. The information that is sent is the name of another port. The -calculus is dened, similarly to the -calculus, using a formal language in which expressions are constructed according to simple syntactic rules, and transformed into other expressions according to simple syntactic rules. The expressions represent dierent interactive systems. Most models of interactive computation work by beginning with a noninteractive model of computation, and adding interaction as an extra layer on top of the non-interactive model. For instance, PTMs begin with the non-

23

interactive Turing machine paradigm, and add extra conceptual apparatus which enables the modeling of interactive systems. The -calculus takes a dierent approach. It takes the notion of interaction as primitive, and all computations, even the simplest computations, are accomplished by systems of concurrently interacting processes. For instance, to add three and three, one would have a process representing the rst three, a process representing the second three, and an adder process which interacted with the two threes to create another process representing a six.

3.1

Denition of the -calculus

We repeat the denition of the -calculus, as given in Milner [1999]. Some further acquaintance with the -calculus is probably necessary in order to read the remainder of this paper, as the -calculus is a fairly complex system. An extended introduction of the -calculus is beyond the scope of this paper; so we refer the reader to Milner [1993]. Let there be an innite set N of names. Names are denoted by lower case letters: x, y, z, .... An action prex represents an atomic behavior which a process can carry out. The possibilities are sending a message, receiving a message, or performing an internal, unobservable action. The set of action prexes is dened by the following syntax: = x(y) xy receive y along x send y along x unobservable action (2)

Denition 3.1.1 The set P of -calculus expressions is dened by the following syntax: P =
iI

i .Pi P1 P2 new a P

!P

(3)

where I is any nite indexing set. The processes i .Pi are called summaiI

tions or sums. The empty sum is written 0. The restriction new y and the input action x(y) both bind the name y. y is free in the output action x y . The set of free names in a process expression P is written fn(P ). The result of replacing all instances of a name x with a name y in a process expression P is written {x y}P . The atomic computational steps of a -calculus process are called reactions. In order to dene the reaction rules we need a structural congruence relation, which says when two process expressions are identical, discounting variations in syntax which have no semantic signicance.

24

Denition 3.1.2 Two -calculus process expressions P and Q are structurally congruent, written P Q, if we can transform one into the other by using the following equations (in either direction): 1. Change of bound names (alpha-conversion); 2. Reordering of terms in a summation; 3. P 0 P; P Q Q P; P (Q R) (P Q) R;

4. new x (P Q) P new yx P ; 5. !P P !P .

new x Q if x fn(P ); new x 0 0; new xy P

Denition 3.1.3 A process expression new (M1 a Mm !Q1 !Qn )

is said to be in standard form if each Mi is a non-empty sum, and each Qj is itself in standard form. (If m = n = 0 then the form is new 0; if is empty a a then there is no restriction.) Proposition 3.1.4 Every process is structurally congruent to a standard form. Denition 3.1.5 The reaction relation over P contains exactly those transitions which can be inferred from the rules in the table below: .P + M P Q P P P Q P Q P P new x P new x P P P if P Q and P Q Q Q

TAU :

REACT : (x(y).P + M ) (x z .Q + N ) {z y}P PAR : RES : STRUCT :

This completes our denition of the -calculus.

25

3.2

Deterministic and non-deterministic processes

As we did with PTMs, we will think of deterministic -calculus processes as modeling physical systems with computable behavior, and non-deterministic calculus processes as modeling physical systems with non-computable behavior. In order to do this, we must dene what it means for a -calculus process to be deterministic or non-deterministic. Intuitively, a process is deterministic if it can react to every input from the environment in only one way. This means that, in the process expressions standard form, there cannot be two input actions receiving along the same channel, and there cannot be two output actions sending along the same channel, except in cases where those two actions guard the same process expression.4 Furthermore, if the process is capable of performing a -transition, performing this transition must be the only thing it is capable of doing. Denition 3.2.1 Let P be a process expression in standard form: P = new (M1 a 1,1,i .P1,1,i ) (
iI1,1 iI1,2

= new a1 (( !(new a2 ( !(new a3 ( !(new a ( m

iIm,1

Mn1 !Q2 1,2,i .P1,2,i ) 2,2,i .P2,2,i ) 3,2,i .P3,2,i ) ( (

!Qm ) 1,n1 ,i .P1,n1 ,i )

iI1,n1

2,1,i .P2,1,i ) (
iI2,1 iI2,2

2,n2 ,i .P2,n2 ,i ))
iI2,n2

3,1,i .P3,1,i ) (
iI3,1 iI3,2

(
iI3,n3

3,n3 ,i .P3,n3 ,i ))

m,1,i .Pm,1,i ) (
iIm,2

m,2,i .Pm,2,i )

(
iIm,nm

m,nm ,i .Pm,nm ,i )))

m is the number of replications plus one, and acts as an index. m = 1 refers to the summations which are not inside a replication. n1 is the number of concurrent, non-replicated summations. I1,a is the indexing set for the terms of the ath non-replicated summation. nj with j > 1 is the number of concurrent summations in the jth replication. Ij,a is the indexing set of the ath summation in the jth replication. If, for all k, j, i, k,j,i = and, for all k, j, i, k , j , i , Pk,j,i Pk ,j ,i , then P is deterministic. If, for all k, j, i, k , j , i , a, x, y:
k,j,i = a(x) and k ,j ,i = a(y) only if {x y}Pk,j,i Pk ,j ,i , and k,j,i = a x and k,j,i = a y only if x = y and Pk,j,i Pk ,j ,i ,

then P is deterministic. Otherwise, P is non-deterministic.

4 We will often run across the latter case, because it obtains in any process expression that involves a replication.

26

3.3

Modeling physical processes

A -calculus process can model any physical system which produces and/or consumes information, and can interact with a computer. As with PTMs, we model non-computable processes as non-deterministic -calculus processes. The set of possible reactions of a process to a given input represents the set of possible behaviors of the real-world system it models in response to that input. In the -calculus, pieces of information (numbers, strings, etc.) are represented as processes. Thus we must model not only the physical information processing system, but also the information that it processes, using -calculus processes. Suppose that we want to model an interactive system in which a human user interacts with a computer via a keyboard and teletype display. Our model will have four processes: the human, the keyboard, the display, and the computer. The computer has an output port along which it sends messages to the display, and an input port along which it receives messages from the keyboard. The human has an output port into the keyboard, and input port from the display. The messages which the processes exchange with each other represent strings.

3.4

Decidability of the reaction relation

-calculus processes cannot compute non-Turing-computable functions. In this sense, they are Turing-equivalent. We want to make a more precise statement of the relationship between the -calculus and Turing machines. We can achieve the desired precision by saying that the reaction relation of the -calculus is decidable. If the reaction relation is decidable, that means that for every -calculus process, there exists a Turing machine which can say what it will do in the future. (For non-deterministic processes, the Turing machine says only what the set of possible futures is, without saying which future actually obtains. This is the same situation that we saw with the timeless simulations of sequentially interactive systems.) The decidability of the reaction relation is predicated on the decidability of the structural congruence relation, since the denition of reaction uses structural congruence (Denition 3.1.18). The decidability of the structural congruence relation, in turn, was historically a dicult open question. However, Engelfriet and Gelsema [1999] gave a positive resolution to this question; the structural congruence relation is decidable. So the way is clear to prove the decidability of the reaction relation. Theorem 3.4.1. The reaction relation is decidable. Proof. Let P, Q P be processes. We want to give an algorithm to decide whether or not P Q. Let P be a standard form structurally congruent to P . Let:

27

= new (( a
iI1

P = new M1 a 1,i .P1,i ) (

iI2

Mn !Q2 (
iIn

!Qm !Qm )

2,i .P2,i )

n,i .Pn,i ) !Q1 !Q2

Furthermore, for all Qi , with 1 i m, let Qi Mj for some 1 j n. That is, let P feature at least one expansion of every replication. We will enumerate a set of standard forms Q P such that P Q i Q Q for some Q Q. Whenever, for some j, i, j,i = , let Pj,i Q. Whenever, for some j, i, j , i , with j j , j,i = x(y) and j ,i = x z , let: M 1 M2

{x y}Pj,i Pj ,i

Mn !Q1 !Q2 !Qm Q.

P Q i Q Q for some Q Q. Given P , it is possible to algorithmically construct P . Given P , it is possible to algorithmically construct Q. Given Q, it is possible to algorithmically decide whether or not Q Q for some Q Q. Therefore, is decidable.

Acknowledgements

I wish to thank Dr. Brad Armendt for his helpful comments throughout the writing process.

References
Douglas Bridges. Computability: A Mathematical Sketchbook. Number 146 in Graduate Texts in Mathematics. Spinger-Verlag, 1994. Paul Cockshott and Greg Michaelson. Are there new models of computation? reply to wegner and eberbach. The Computer Journal, 50(2):232247, 2007. Gordana Dodig-Crnkovic. Signicance of models of computation, from turing model to natural computation. Minds and Machines, 21:301322, 2011. Eugene Eberbach, Dina Goldin, and Peter Wegner. Turings ideas and models of computation. In Alan Turing: Life and Legacy of a Great Thinker, pages 159194. Springer-Verlag, 2004. Joost Engelfriet and Tjalling Gelsema. Multisets and structural congruence of the -calculus with replication. Theoretical Computer Science, 211(1):311 337, 1999. D. Goldin and P. Wegner. The church-turing thesis: Breaking the myth. In New Computational Paradigms, volume 3526 of Lecture Notes in Computer Science, pages 152168. Springer-Verlag Berlin, 2005. 28

D. Goldin and P. Wegner. The interactive nature of computing: Refuting the strong church-turing thesis. Minds and Machines, 18(1):1738, 2008. Dina Q. Goldin. Persistent turing machines as a model of interactive computation. In FoIKS, volume 1762 of Lecture Notes in Computer Science, pages 166135, 2000. Dina Q. Goldin, Scott A. Smolka, Paul C. Attie, and Elaine L. Sonderegger. Turing machines, transition systems, and interaction. Information and Computation, 194:101128, 2004. Harry R. Lewis and Christos H. Papadimitriou. Elements of the Theory of Computation. Prentice-Hall, 1981. Robin Milner. The polyadic -calculus: A tutorial. In F.L. Hamer, W. Brauer, and H. Schwichtenberg, editors, Logic and Algebra of Specication. SpringerVerlag, 1993. Robin Milner. Communicating and Mobile Systems: The -Calculus. Cambridge University Press, 1999. Gualtiero Piccinini. The physical church-turing thesis: Modest or bold? British Journal for the Philosophy of Science, 62:733769, 2011. Tibor Rad. On non-computable functions. Bell System Technical Journal, 41 o (3), 1962. Scott A. Smolka, Dina Q. Goldin, and Peter Wegner, editors. Interactive Computation: The New Paradigm. Springer-Verlag Berlin, 2006. Alan Turing. Systems of logic based on ordinals. Proceedings of the London mathematical society, 45, 1939. Jan van Leeuwen and Ji` Wiedermann. Beyond the turing limit: Evolving r interactive systems. In SOFSEM 2001: Theory and Practice of Informatics, volume 2234 of Lecture Notes in Computer Science, pages 90109. SpringerVerlag Berlin, 2001.

29