… no computer of the sort we know how to build … will ever cross a threshold to become aware of what it is doing. No chess program, however advanced, will know it is playing chess any more than a washing machine knows it is washing clothes. Today’s most powerful computers differ from an abacus only in their power to obey more complicated algorithms … [Martin Gardner]
There is a vast literature on the subject of why computation is insufficient to explain the functioning of natural neural systems. The objections range from the possibility of neurons having quantum abilities to ontological objections that claim computation is at its heart merely
You may feel, for example, that from observing your dog patiently waiting for you to finish eating and watching your face intently for signals when he is allowed to eat that the dog has a
While it seems intuitively obvious that ‘I’ am self-aware and by extension others like me must also be self-aware (particularly, in respect of the fact that they use language like I do and they assert that they too are self-aware) this intuition does not extend to the nature of what this mind-entity might be. We may not know what it is and we may not be able to investigate it empirically but we most certainly can subject it to rigorous logical thinking. As our history of mythmaking and story telling makes almost self-evident, the first step is always using rational thinking to remove mythological cruft. It is most certainly not true that the self-conscious self-aware mind revolves around us. We are simply one of many creatures which have evolved in our environment and we are part of a broad range of animals which are very similar and which have a common ancestry. Accepting that these broad range of natural organisms (some of which we hunt and eat) are also self-aware in the same way we are would be a first step in building a more general understanding of what is is that our sense of self actually is. Our conscious mind may be mysterious but the purpose of logical rational thinking is to make it less mysterious. Even if we are incapable of fully understanding it, we can step-by-step decrease our level of ignorance.
The tool to building a greater understanding of our mind is invariable computation. The increasing understanding of the great power of computation has led to a number of objections that computation will never be sufficient either to explain our own minds or to be sufficient to build ‘artificial’ minds. Generally these objections are based on a flawed understanding of computation. Martin Gardner sums one general approach; “Today’s most powerful computers differ from an abacus only in their power to obey more complicated algorithms…”. The very plain flaw in understanding here is that an abacus is a tool for calculation rather than for general computation. Misunderstanding the difference between calculation and computation lies at the heart of most of the objections to ‘powerful computers’. What can be ‘infuriating’ (in the sense that Hofstadter means) is that the use of terminology is often so hopelessly misguided that it borders on sophistry. The single sentence by Gardner (who is often celebrated as a beacon of rational thinking) is a conflation of muddled thinking and misused terminology. All current digital computers, no matter how ‘powerful’ have exactly the same Von Neumann architecture. In a theoretical sense even the oldest simplest computer is just as ‘powerful’ as any existing super-computer. Any computer, no matter how un-‘powerful’ can run exactly the same algorithms. Algorithms (or rather problems) differ in the order of their complexity (solvable in polynomial time for example). An algorithm is the step-by-step solution to a problem. Any algorithm, no matter how complex, can be implemented on any system that is Turing-complete. An abacus is of course a calculating tool, which is incapable of computation and is not Turing-complete. While it is true that a system that does calculation may be seen as less ‘powerful’ than a system which is capable of computation (because calculation is a limited form of computation), the idea that computers or calculators “obey” algorithms is simply misguided. A computer (or indeed a calculator) may be used to implement an algorithm, but this does not mean that this is what computation inherently is, just as they are not inherently problem solvers. Algorithms are how we usually interact with computers and calculators, and it is we who impose this idea onto systems of computation. It would be more correct to say that computers run programs and that algorithms are implemented as part of the program. Most of the things that programs do are in fact housekeeping tasks rather than implementations of specific algorithms. Indeed, one of the most important instructions for most practical processors is the NOP instruction, which is simply a placeholder and performs no operation.
So what exactly is a computer and how does it differ from a calculator? There are a variety of ways to define computation, all of which can be shown to equivalent to each other. The earliest is probably the Turing machine, which is probably one of the least elegant and most unintuitive model of computation of all the possible abstract models of general computation. It originates from a time when large open reel magnetic tape was a new and advanced technology. A Turing machine is a state machine which has the ability to read from and write to a tape that is theoretically unbounded on either side. The tape is divided into discrete locations, which have no address but which are exactly identical in size, and a single (monospaced) symbol may be written at each location. All locations on the tape which have not been written to are assumed to be empty, which can be represented by a symbol for ‘blank’. The simplest alphabet of symbols consists of just a ‘1’, with ‘blank’ used to separate groups of symbols. While Turing machines are simple, they are not very practical and they also do not illustrate or model the nature of computation very effectively. One of their deficiencies is that they obscure the difference between calculation and computation. This is because Turing machines operate on any set of symbols rather than being specifically numerical. An analagy may be drawn with the Roman numeral system, where at its heart a number is represented simply by a counting symbol (which is not the number 1, but simply a marker to indicate number – as in 5 sheep are represented by 5 marks and 50 cows are represented by 50 of the same marks). Getting a Turing machine to perform even the simplest of arithmetic operations is a laborious task, in a similar way that basic arithmetic using Roman numerals is laborious and unintuitive.
Calculation of course consists of operations on numbers, and computation is best thought of as an extension to calculation, and therefore also inherently numerical. A calculate-tor is at its heart a device which represents or stores numbers (of which an abacus is probably the earliest example). Storing numbers requires a memory, and to be useful more than a single number needs to be stored. To make operations on numbers practical and useful the stored numbers should each be given an address. This can be thought of in the same way as the tape of a Turing machine with an ‘alphabet’ consisting of all possible numbers and with each location having an address to which the reading/writing tape head can move to instantaneous (in the same way as a Turing Machine moves just one space to the left or right). A calculator also does not require complex states, but merely simple sequential operations; which can be thought of as a one dimensional state table where one state always lead just to the next state in the list. Whereas a Turing machine reads from the tape and then decides what to do based on the input, a calculator just performs an operation irrespective of what a memory location contains. Because a Turing machine performs an operation depending on the input, it needs to be represented by a table which defines what operation to perform depending on the input and then what state to go to (which also depends on the input). A calculator does not require this decision making, and as a result does not require a complex table to represent its function – it requires only a sequential list of simple basic operations. An operation consists of just the memory address the operation is to act on and the identity of the operation. Because memory is addressed we can now represent memory locations as variables and operations as actions on a variable. This allows us to think of calculation in terms of a ‘programming language’ with a set of ‘instructions’. What for a Turing machine would be represented as a state table, can in its simplified form for calculation be seen as an ordered list (or sequence) of individual instruction words – which is what we normally refer to as a ‘program’.
Defining calculation formally as a sequential list of instructions carried out on numbers allows us to ask what are the simplest and smallest number of instructions that are capable of supporting all possible calculations on numbers. The answer to this question has great practical importance and forms the heart of all current implementations of arithmetic and logic. It can be shown that arithmetic functions can be calculated using only two simple operations: increment and decrement.
V ￩ V + 1 /* Increase by 1 the value of variable V */
V ￩ V - 1 /* Decrease by 1 the value of variable V */
/* … unless */
/* if V is 0 */
/* then leave it unchanged at 0 */
It is immediately apparent that having an instruction set that consists purely increment and decrement is very limiting. Even the simplest arithmetic function would require very long lists of instructions. It would be very convenient to be able to repeat instructions until a certain condition is met. A condition is needed because otherwise repetition will never stop, and never-ending repetition is hardly very useful. Conditions can be thought of as different states if implemented with a state machine. The decrement instruction on positive integers technically requires two states, one for the zero condition and another for the non-zero condition. This condition could be expanded so that one of the states leads to a previous state in the list rather than the default next state in the list. This small modification would not change the basic structure of a program as a sequential list of instructions but it does allow a restricted means of escape from the ‘mechanical’ sequence of calculation. How restricted this means of escape is differentiates calculation, computation and several other levels in the hierarchy of automata (abstract machines). The simplest modification would be to add to the zero condition of the decrement statement. We could, for example, modifiy the decrement statement to go to the next instruction only on the zero condition and to repeat the current statement otherwise; which would allow us to decrement arbitrarily large numbers to zero without the need of a very long program. However, sometimes we might just wish to use decrement a single time and so we might have two forms of decrement; a looping decrement and a single decrement. Generalizing the idea of a conditional which is evaluated (which in the simplest case, is to decide whether to proceed to the next instruction or whether to repeat the current instruction) leads to viewing the instructions of a program like the tape of a Turing machine; instructions do not necessarily need to proceed linearly only one direction from beginning to end, but the instruction flow could for example be reversed just like the head of a Turing machine can move in one direction or the other. Being able to reverse the flow of instructions is simple, but like Turing machines and roman numerals, not very convenient. Generalizing the instruction flow in a list, leads us to the idea of ‘branching’ within the list. In the simplest case, an instruction is not automatically followed by the next instruction in the list but rather it branches to the next instruction in the list. We could also branch to the current instruction or to the previous instruction. We could expand this further and branch not just to the previous or next instruction but to 10 instruction before or after the current instruction; or maybe 100 or 1000 … and more generally n instructions. This is referred to as a ‘relative jump’ instruction and is in an essential instruction in practical computation. In its most complete form this consists of an entirely new instruction – the conditional branch instruction. If the language of the program is restricted to non-negative integers then a conditional jump might be restricted to going back. If a conditional jump forwards is required this can be achieved by adding a jump forward instruction. Generalizing relative jumps even further, leads us to jumping to absolute positions a program rather than positions relative to the current position. But this would require a further addition to the formal language – a label for those instruction in the list which are distinations for a conditional branch.
V ￩ V + 1 /* Increase by 1 the value of variable V */
V ￩ V - 1 /* Decrease by 1 the value of variable V */
/* … unless */
/* if V is 0 */
/* then leave it unchanged at 0 */
IF V ≠ 0 GOTO N /* If the value of variable V is 0 */
/* go to plus or minus N'th location */
/* in the list of instructions */
/* Else go to the next instruction */
The addition of a conditional branch instruction makes the instruction set fully Turing-complete. This means that a program can be written using the instruction set that is capable of fully emulating a Turing machine, and therefore the instruction set may be thought of as being capable of general computation. Restricting the conditional branch (such as allowing only backward relative jumps) differentiates the hierarchy of automata; from calculation being the simplest and computation the most complete.
/* Addition: f(X1,X2) = X1 + X2 */
[1] Y ￩ X1
[2] Z ￩ X2
[3] IF Z ≠ 0 GOTO +2
[4] GOTO +4
[5] Z ￩ Z - 1
[6] Y ￩ Y + 1
[7] GOTO -4
[8] NOP /* End */
The code in the table above shows an example program that implements addition. By convention the variables X are considered input, the variables Y are considered the output and the Z variables are considered local variables. If more than a single variable is needed they are numbered, indicated by the subscript. The instructions of the program are also numbered, which in this case is not a formal part of the programming language but rather is used to keep track of the relative jumps. A program that uses absolute jumps would require the numbers to be part of the language itself (as labels). The program also uses some simplifying conventions. There is no plain GOTO instruction in the instruction set, but we can create such an instruction by simply incrementing an otherwise unused variable and then using the conditional branch instruction. For a NOP (no operation) instruction we can likewise set an otherwise unused variable to zero and again use the conditional branch instruction, and the condition will in this case always fail and so the program will always go to the next instruction, meaning the instruction in effect does nothing. The use of simplifying macros like this makes it easier to understand a program. It should be understood though that any macro can always be replaced by a sequence of instructions that uses only instructions from the real instruction set.
Extending the language of calculation therefore allows us to fully encompass computation. The importance of this is that this model of computation is purely numerical, as opposed to Turing machines which can function on arbitrary symbols, which can be interpreted as numbers but are not in themselves numerical. Restricting computation to the language of numerical calculation is not a limitation as both systems can be shown to be equivalent. But yet not only is the language of calculation much simpler than a Turing machine, it also has the advantage of making it straight forward to define a formal language in which the expressions (instructions) are by default evaluated linearly, with the only exception being conditional branching. Another advantage of using the numerical language of calculation is that it closely resembles the languages of practical computing, which have almost without exception converged on implementations of a general von Neumann architecture. Under this architecture programs are coded numerically and stored in memory alongside data. This makes it possible for programs to write other programs and also for a programs to modify themselves. This is something that Turing machines and calculation machines are incapable of. A Turing machine cannot modify its own states and a calculating language such as the one outline above, although it can refer to the individual instructions of a program by the use of labels, cannot modify the list of instructions that constitutes the program in any way. While the ability to self-modify is little remarked upon in the theoretical study of compution, self-reference is considered the defining feature of the ‘conscious mind’ by authors such as Hofstadter. While this appears at first glance an ability that Turing machines and calculating machines are incapable of, it is possible to simulate this ability by a layer of abstraction. A Turing machine can, for example, be created that simulates other machines, including other Turing machines. These simulated machines are capable of self-reference and self-modification and therefore Turing machines can in this way be shown to be capable of universality. However, this layer of abstraction is unintuitive and impractical.
While it is difficult to determine whether a system of computation could ever become more than a ‘number-crunching automaton’ and become ‘conscious’ with a self-reflecting ‘mind’, this is because the terms are ill-defined and poorly understood. We may intuitively feel that we are a self-reflecting conscious mind but those feelings have withstood centuries of attempts to understand them from a rational scientific point of view. On the other hand, counter-intuitively, rigorous scientific investigation of our physiology has shown that whatever we believe ourselves to be, we now know that our conscious mind is the product of a neural system that is based on the simple principle of relaying information from a sensor to a motor. Since sensors inherently provide a numerical measurement and a motor control is also inherently numerical, we know that that neural systems are very likely to be fundamentally numerical in nature. The study of simpler organisms shows that we have evolved from organisms in which the role of neurons is simply to transmit sensor input directly to motor output. This activity is inherently numerical in nature, although the numbers involved are not ‘digital’. We may be much more complex than a jellyfish, but the basic function of our neural system remains to produce motor output using the input from the sensors. The only difference is that the directness between sensor input and motor ouptput has increasingly diminished as we have evolved from the simplest of multi-cellular animals to complex self-reflective thinking beings. We can, therefore, with reasonable certainty know that whatever it is that neural systems do, that this function is numerical in nature, and therefore, that not only is it inherently computational in nature but we also know (with absolute certanty provided the assumptions are true) that the systems of computation that we design and build are fully capable of emulating the function of any neural system, no matter how different the underlying principles of its design might be. These systems are also numerical in nature, although they are inherently restricted to representing the digits of integers (hence referred to as being ‘digital’). Interestingly, the widespread adoption of digital computation demonstrated early on the essential need to represent continuous values, which has been implemented and formalized as ‘floating point’ numbers.
Although neural signals superficially appear to be digital with all-or-none action potentials, the way information is coded is not the same as the digits of numerical calculation. For numerical information transmission there are two fundamental ways to code the information: digital and analog. This is illustrated by the design of optical storage, which is almost universally digital with the exception of early video encoding where the information storage needs were too great for the media available at the time. The laserdisc uses the same transition coding mechanism as the digital audio compact disc but the information coded is an analog signal rather than numbers which are transformed from digital to an analog audio signal for compact disc. With a Laserdisc it is the distance between the transitions that is used to code the signal. This is very similar to the way that neurons code information, which is by distance between action potentials. This suggests that neural systems rely on an analog form of computation. It is ironic that we use transistors, which are inherently analog semi-conducting devices to implement digital computation whereas natural neural systems have evolved to process analog information using the digits of discrete action potentials.
While it is almost certainly true that the computation by natural neural systems could be carried out by digital computation, how this might be achieved is far from self-evident. While a self-reflecting conscious mind is an ill-defined phenomenon, there are other more concrete abilities of neural systems that are more easy to define. One of those abilities that stands out as one of the defining features of neural systems is the ability to adapt and learn. Natural neural systems appear to be capable not only of storing information but to change and adapt in ways that appear to contradict what the fixed ‘number-crunching’ algorithms of computation are capable of. A fundamental objection to understanding natural neural systems in terms of computation is therefore that the theoretical automata of computation are incapable of the type of change involved in ‘learning’. In terms of general computation, the term learning may be defined as fundamental self-change. Turing machines and calculation systems are incapable of changing their own state table or program and a learning system may be defined as any system capable of this type of change. It can be demonstrated that natural neural system are capable of this type of change, and therefore an objection to the claim that natural neural system can be emulated or simulated by computation is that natural neural systems are demonstrably capable of something which no Turing machine or calculation system can ever do. This is a useful objection, because the term ‘learning’ can be made much more precise than its more general intuitive use. Unfortunately, while the literature is rife with claims that computation is incapable of the ‘singularity’ of a conscious mind the more rigorous claim that computation is incapable of learning is much more rarely made. Quite the contrary, the many and varied claims that so called artificially ‘intelligent’ algorithms are capable of learning go largely unchallenged. What is referred to as ‘learning’ is often simply a change of parameter, with the algorithm itself remaining unchanged.
We have made the idea of a program rigorously precise by setting out the language of calculation with the increment, decrement and conditional branch statements that allows the language to be Turing complete. A program is a finite list of these statements. Programs are able to read and write from a memory and this allows a program to adapt its function progressively, by storing information. A program can, for example, remember your name once it has been provided. This form of adaptive computation is widespread in the realm of practical computing. The information is stored as a set of parameters, which are used when available. Their use, however, is pre-determined in the program itself, although this might not be evident to an exernal observer. Parameters can also be ‘hidden’ so a program might give the appearance of adaptation and change. Nevertheless, no matter how ‘big’ the parameter data might be, any semblance of ‘learning’ would be illusory. True learning would require change to one or more of the statements of the program, and this is not possible with either a Turing machine or a calculation machine.
The importance of the game of chess is not in that we know we are playing chess or even that we are aware of the game in an abstract sense, but rather that we are able to learn to play the game at all. A human individual with no prior knowledge is able to learn the game purely by visually observing a few incomplete examples of the game being played or he can learn to play the game purely from a verbal description. No system of computation has so far been demonstrated that is capable of learning to play chess, or indeed any other game, without the algorithm for the game being written by a human programmer. While many and varied algorithms have been demonstrated that are able to play chess, none of these algorithms modify even a single instruction of their initial program and therefore are inherently incapable of learning, irrespective of the many and varied claims that these ‘programs’ play at a level equal to that of a human player. Indeed, a recent innovation in game playing are algorithms that not only lack any ability to know they are playing the game but do away with the need to develop the ability to play the game, creating instead an illusion of play. It is currently fashionable to refer to this illusion as ‘learning’ and ‘artificial intelligence’.
How could a chess program play chess without any ability to play chess? This leads naturally to a well known objection to computation known as Searle's Chinese room