From: Thomas Walker Lynch Date: Sun, 9 Aug 2026 06:42:12 +0000 (+0000) Subject: . X-Git-Url: https://git.reasoningtechnology.com/%27%20%20%20window.RT.dirpr_library%20%20%20%27/Hindu-Arabic%20number%20fig%201.png?a=commitdiff_plain;h=34602a032f2a9d94aeff93f1f7a85a5bbde27120;p=TM-2026 . --- diff --git a/document/book/TM-2026.html b/document/book/TM-2026.html index 307c98e..8e822c7 100644 --- a/document/book/TM-2026.html +++ b/document/book/TM-2026.html @@ -33,7 +33,7 @@ - Terminology + Nomenclature

All communication is founded upon common knowledge, so here are some notes on the conventions used in this book.

@@ -42,7 +42,7 @@

The unicode middle dot, ·, is used as an ad hoc namespace operator in identifiers. Hence, N·x, would be the variable x from the N namespace. This is a typography symbol. It can be seen for example when words are broken into symbols, e.g. 'op·er·a·tor', and sometimes in names, such as 'Leonardo da·Vinci', and 'Vincent van·Gogh'. It is accepted in identifiers by modern C compilers, and it is part of the RT·gcc compiler mods for gcc.

-

I have experimented with modern gender forms in technical language in past writings. For example, I used the plural-as-singular style in one piece, and was applauded by some, though categorized as illiterate by others. Since then, I have evolved a writing style that emphasizes using roles as subjects: the mathematician, the author, the programmer. Such subjects are singular, so for grammatical agreement, I use the inclusive he. It is structurally much cleaner to use he as inclusive of all people than it is to gray out an entire category of plural agreement pronouns by forcing words such as "they" to take on a singular form. I use "a person" when the subject is an unknown third party, potentially even being an AI. I prefer this over the 'one' of 'One does this, or one does that.' so that 'one' can be reserved to unambiguously refer to the natural number.

+

I have experimented with modern gender forms in technical language in past writings. For example, I used the plural-as-singular style in one piece, and was applauded by some, though categorized as illiterate by others. Since then, I have evolved a writing style that emphasizes using roles as subjects: the mathematician, the author, the programmer. Such subjects are singular, so for grammatical agreement, I use the inclusive he. It is structurally much cleaner to use he as inclusive of all people than it is to gray out an entire category of plural agreement pronouns by forcing words such as "they" to take on a singular form. I use "a person" when the subject is an unknown third party, potentially even being an AI. I prefer this over the 'one' of 'One does this, or one does that.' so that 'one' can be reserved to unambiguously refer to the Natural Number.

In the prior edition of this book, the preface included a discussion on the meaning of the word "may" according to RFC 2119, the guidelines for specification writing. There is an important distinction between the 'may' of options or permission, and the more colloquial 'may' of probability. However, distinguishing between the two was too much of an ask of readers, most of whom skip the preface anyway. So in this edition, I avoid the temptation to use 'may' and replace it with a direct statement of what I mean. "It is of high probability that..." or "There are options for...". Directly saying what is meant, who would have thought of it? The RFC 2119 authors have apparently struggled with this as well, as they now require the MAY and the other words that appear in RFC 2119 to be capitalized so as to dodge the grammar debate.

@@ -82,6 +82,25 @@

Dates and times are given in the ISO 8601 format. The components run from the most-significant to the least-significant, year, then month, then day, in the same order the digits of a Hindu-Arabic numeral run. Two consequences follow from that ordering, and both are the reason for choosing it. A lexicographic comparison of two such dates agrees with their chronological comparison, so a list of them sorts correctly with no collation rules particular to dates. And the format is unambiguous, whereas a date such as 03/04/2026 is read as the third of April by some readers and the fourth of March by others. A time of day, when one is given, follows the date, and a trailing Z marks the time as UTC. Hence 2026-06-01 08:28:00Z. Where a date appears without a time, the date alone is intended, e.g. 2026-06-01.

+

+ Several words in this book carry a formal definition that distinguishes them from their ordinary English counterparts, so they are capitalized: Natural Number, Integer, Rational, Real. The word real is the perhaps the best example of why this is done. It was too much of an ask by mathematics to remove it common English or to explicitly disambiguate it. Hence, 'Real' is the object mathematics defines, and 'real' is the ordinary English word. Integer suffers no such ambiguity, but it is capitalized for consistency with its siblings. +

+ +

+ Natural Numbers begin at zero, while Counting Numbers begin at one. The word Natural in front of Natural Number is overloaded. Counting Numbers are also Natural according to the thesis of this book, as are Rationals and even Reals. Enlightenment era thinkers did not carry it that far. So 'Natural Number' is a number as defined as Peano + + +In a book with the thesis that all number types stem from a Naturalism interpretation, all numbers are Natural. Note also that the Natural of Natural Number is inherited from mathematics and has nothing to do with the Naturalism this book argues from. Every number kind here is arrived at naturalistically, the Integers and the Rationals and the Reals along with the Naturals, so Natural Number should not be read as naming the naturalistic one. It names what a Peano machine outputs. +

+ + +

+ In this book, a Natural Number is what a Peano machine outputs. An Integer, a Rational, and a Real are likewise the outputs of machines, each constructed in its turn. Because these name machines, and because this book capitalizes the names of machines, as in Turing Machine and TTCA Machine, they are capitalized here as well. The lower case forms are reserved for the ordinary mathematical notions and for the fixed-width values a contemporary architecture provides. So a reader will find the natural numbers of arithmetic, the real field, and the 32 bit integer of a conventional processor in lower case, while the machines this work constructs, and the values they produce, are in upper case. + + +The distinction is not decoration. A Natural Number is arrived at by construction and carries its derivation with it, whereas an integer is stipulated by an architecture and carries a width. The two cases also mark a distance this book intends to close. Lower case names a notion as the tradition hands it to us, upper case names the same notion as constructed here, and the argument of the later chapters is that the tradition's notion was a machine's output all along. +

+ @@ -100,7 +119,7 @@

There is a practical aspect to this work. A software library that is of general usefulness can be found in these pages, and downloaded from GitHub. The library was first articulated in the Lisp language in the first edition of the book and released on Quicklisp. Lisp is in a sense pure, and formal statements can be made with it. Using it for the library made the library a natural small step away from the formal discussion that came before it was presented. Since that time I have written parts of the library in other languages and found it very useful. This volume presents the Python API.

-

A natural number is a computational structure, as described by Peano. It starts with emptiness, a zero, and is then built up by repeated application of the successor function. Because a number is a computational structure, number theory was already computation theory before Church, Turing, and their contemporaries gave the subject its name. It is a computation theory whose discussion is confined to the relationships among Peano structures, which is to say, to natural numbers. Then the activity of writing algorithms and designing circuits that relate those structures to one another, in the service of solving real problems, is applied number theory.

+

A Natural Number is a computational structure, as described by Peano. It starts with emptiness, a zero, and is then built up by repeated application of the successor function. Because a number is a computational structure, number theory was already computation theory before Church, Turing, and their contemporaries gave the subject its name. It is a computation theory whose discussion is confined to the relationships among Peano structures, which is to say, to Natural Numbers. Then the activity of writing algorithms and designing circuits that relate those structures to one another, in the service of solving real problems, is applied number theory.

@@ -243,7 +262,7 @@

- Before asking whether a given architecture measures up to the Turing Machine, we need to say what measuring up would consist of. Like a Turing Machine, a computer architecture is an abstraction. The box sitting on a person's desk is a realization of some computer architecture. To say a Turing Machine does something is to say that the Turing Machine was analyzed and the result of the analysis is that 'something'. A computer architecture can also be analyzed. A computer architecture is said to be Turing Complete when, through analysis, it is determined that it can do anything that a Turing Machine can do. The practical implication for a realization of such an architecture is that running a program will fault only because a) the program logic told it to, b) the program has a flaw, or c) there is a mathematical fact standing in the way of execution. A shortage of a physical resource is not a fourth reason, provided the architecture can pause a program until a 'more memory' request is fulfilled, because that shortage is a limit of the realization and not of the architecture. However, if the architecture itself stipulates a bound that a program can reach, such as a fixed address width or a fixed integer width, then every realization of it must fail on some program that a Turing Machine would carry to completion, and the architecture is not Turing Complete. + Before asking whether a given architecture measures up to the Turing Machine, we need to say what measuring up would consist of. Like a Turing Machine, a computer architecture is an abstraction. The box sitting on a person's desk is a realization of some computer architecture. To say a Turing Machine does something is to say that the Turing Machine was analyzed and the result of the analysis is that 'something'. A computer architecture can also be analyzed. A computer architecture is said to be Turing Complete when, through analysis, it is determined that it can do anything that a Turing Machine can do. The practical implication for a realization of such an architecture is that running a program will fault only because a) the program logic told it to, b) the program has a flaw, or c) there is a mathematical fact standing in the way of execution. A shortage of a physical resource is not a fourth reason, provided the architecture can pause a program until a 'more memory' request is fulfilled, because that shortage is a limit of the realization and not of the architecture. However, if the architecture itself stipulates a bound that a program can reach, such as a fixed address width or a fixed Integer width, then every realization of it must fail on some program that a Turing Machine would carry to completion, and the architecture is not Turing Complete.

@@ -255,7 +274,7 @@

- Notice where the failure actually sits. Expanding the memory available to a process is handled, and handled well. What is missing is the ability to continue rather than to terminate, and supplying that is software's work, much as Python supplies integers of arbitrary range over a machine whose integers are of fixed width. The difference is one of motive. Python's arbitrary range integers are a convenience offered to the programmer, whereas here the software would be compensating for a bound the architecture imposed. This is the shape of the whole problem in miniature: an architecture is made to look complete by software written to work around it, rather than being complete by virtue of its own instructions. + Notice where the failure actually sits. Expanding the memory available to a process is handled, and handled well. What is missing is the ability to continue rather than to terminate, and supplying that is software's work, much as Python supplies Integers of arbitrary range over a machine whose Integers are of fixed width. The difference is one of motive. Python's arbitrary range Integers are a convenience offered to the programmer, whereas here the software would be compensating for a bound the architecture imposed. This is the shape of the whole problem in miniature: an architecture is made to look complete by software written to work around it, rather than being complete by virtue of its own instructions.

@@ -263,7 +282,7 @@

- To complete the Turing Machine story, then, we will transform the Turing Machine into a modern architecture in a stepwise fashion, while ensuring that at each step the modifications are inconsequential to computation theoretic existence proofs and complexity class results. The transformation does not run in one direction only. On the Turing Machine side, the controller has to stop being used as memory. On the modern side, the fixed widths an architecture stipulates, of an address and of an integer, are what have to give way. The two meet in the middle, and the machine we arrive at is less strange than that might suggest. It separates the control path from the data path, it holds an instruction table, and it has a small register file. It looks modern. The differences from what we currently build are real but few, and the point of the exercise is that we could build it. + To complete the Turing Machine story, then, we will transform the Turing Machine into a modern architecture in a stepwise fashion, while ensuring that at each step the modifications are inconsequential to computation theoretic existence proofs and complexity class results. The transformation does not run in one direction only. On the Turing Machine side, the controller has to stop being used as memory. On the modern side, the fixed widths an architecture stipulates, of an address and of an Integer, are what have to give way. The two meet in the middle, and the machine we arrive at is less strange than that might suggest. It separates the control path from the data path, it holds an instruction table, and it has a small register file. It looks modern. The differences from what we currently build are real but few, and the point of the exercise is that we could build it.

@@ -379,199 +398,211 @@ Computation theoretic consequentiality -

- The Turing Machine is an abstraction, as are architectures, organizations, and implementations. Only a computer realization is concrete, but even then we can make observations that are analogous to properties of an abstraction. Hence, we can use the language of mathematics to talk about machines at all of the levels. -

+

+ The Turing Machine is an abstraction, as are architectures, organizations, and implementations. Only a computer realization is concrete, but even then we can make observations that are analogous to properties of an abstraction. Hence, we can use the language of mathematics to talk about machines at all of the levels. +

-

- When a transform applied to machine m_i produces machine m_{i.1}, and this latter machine gets the same results for the same computational inputs, and furthermore, if any computation theory analysis applied to m_{i.1} yields the same existence and big O results as it would when applied to m_i, we say that the transform is computation theoretic inconsequential. Otherwise, the transformation is said to be computation theoretic consequential. The remainder of this section defines these terms more precisely. -

+

+ Suppose a transform applied to machine m_i produces machine m_{i.1}. Suppose further that this latter machine gets the same results for the same computational inputs, and that any computation theory analysis applied to m_{i.1} yields the same existence and big O results as it would when applied to m_i. Then we say that the transform is computation theoretic inconsequential. Otherwise, the transformation is said to be computation theoretic consequential. The remainder of this chapter defines these terms more precisely. +

Orders of analysis -

- The definition just sketched turns on applying computation theory analysis to a - machine rather than running it. That is a distinction the reader will meet - repeatedly, in places that have nothing to do with transforms, so it is worth - settling here. A fuller treatment, and a system built upon it, comes in the - chapter on computational analysis, chapter - . -

+

+ An analyzer is a program that examines the definition of another machine, or of another program, so as to deduce properties of it. Those properties could be anything. What results the machine produces is one of them, but so are whether it halts, how much tape or how many steps it consumes, and whether it ever enters a given state. The definition being examined is called the analyzed program or analyzed machine. +

-

- We call a program that examines another program so as to deduce properties of its results an analyzer. The program or machine definition being subjected to this evaluation is called the analyzed program or analyzed machine. -

-

- Turing Machines that halt in a finite number of steps for any finite input within a stipulated domain are said to be computational over that domain. -

- -

- By definition, first-order analysis is the running of programs, and it has its place. - Generally, when we want to know what output a computational machine will produce, the fastest route to this knowledge is to run the program. Most programs written to solve problems are most effectively run to solve those problems rather than analyzed to deduce what they will produce. -

+

+ Turing Machines that halt in a finite number of steps for any finite input within a stipulated domain are said to be computational over that domain. +

-

- Now suppose we quantify the inputs to a computational machine over a domain and want to know a property of the machine. Perhaps, say, that it always produces an even number. If the quantification is over a large set, then it might be faster to study the machine than it would be to run the machine on every input in the domain while checking its output. -

- -

- Further suppose that the quantification is over an infinite input space. Then the only option for answering a question about the properties of results from such a machine is to analyze it. This is second-order analysis, also called simply analysis. -

- -

- Famously, we know that universally an analyzer cannot determine if a machine is computational. This knowledge was derived by reasoning about the properties of a hypothetically existing analyzer machine. This is a third order analysis activity. -

- - - - Definition of the same results transform property - -

- Suppose we are interested in a given Turing Machine m_i where the machine will potentially be run after being given any one of a number of input tapes x_{i,j}, and for each of those inputs the same tape with the results written will be r_{i,j}, then we notate this as: -

- - - - - m_i(x_{i,j}) = r_{i,j} - - eq: Machine m_i given input tape x_{i,j} writes result tape r_{i,j} - - -

- Here the subscripts of the same name set up a correspondence. x_{i,j} is the jth input to the machine m_i, etc. The free variable j runs over all the interesting distinct input tapes to be given to machine m_i. So for example, if we had a machine, say m_8, and we had a set of three inputs to be given to m_8, then: -

- - - - - \begin{aligned} - m_8(x_{8,0}) &= r_{8,0} \\ - m_8(x_{8,1}) &= r_{8,1} \\ - m_8(x_{8,2}) &= r_{8,2} - \end{aligned} - - eq: Machine m_8 over a set of three input tapes - - -

- Another machine, perhaps machine m_7, would have its own distinct inputs x_{7,j}, etc. -

+

+ In the introduction we gave an informal definition of analysis as that of running a Turing Machine analyzer that has encoded as data on its tape a Turing Machine that is being analyzed. A refined definition is given in this section. +

-

- Now suppose that a machine m_{i.1} is the result of a transformation, T, applied to machine m_i. -

+

+ A first-order analysis is the running of a Turing Machine with a fixed controller, or of a Universal Turing Machine with a stored program. The thing being analyzed is the data on the tape. Up until this point in the book, this has been simply called running the machine. +

- - - - m_i \xrightarrow{T} m_{i.1} - - eq: Transform T carries machine m_i to machine m_{i.1} - +

+ The usage of the term analysis in the introduction is formally called second-order analysis. A second-order analysis is assumed if no order is specified. +

-

- We can then assign a property to transform T called its doesn't change results property, as follows. If and only if: -

+

+ Here is an interesting question. Suppose that instead of running a machine, which is to say performing a first-order analysis, to discover what the machine outputs on a tape, a second-order analysis is used to determine this. Say for example the program is that of a decider, and it will print 'Y' or 'N'. It might be that for a given input the program wastes a lot of time going through the motions when the output is would be immediately apparent to an analyzer. Generally, such a second-order analyzer that determines the output of another program must interpret the instructions found in the analyzed program in order to find the output. Interpretation is almost always slower than directly running the machine to get its output, a first-order analysis, as a lot of additional work must be done. An analyzer looking for shortcuts would be merely discovering things that would have been missed optimization opportunities when the analyzed program was written. +

- - - - \forall j \colon r_{i,j} = r_{i.1,j} - - eq: The doesn't change results condition for one machine - +

+ In first-order analysis the only way to learn if a property holds for a machine when the input is quantified over a domain is to modify the machine, or the program, to monitor said property, and then run the machine over all inputs in the domain. In a case such as this, second-order analysis can be faster. Say for example the property question is whether the machine always outputs an even number. An analysis program might discover that the machine increments an even value by two, or that before output a state value is multiplied by two, and then resolve quickly. The leverage the second-order analysis has is that it only need be run once. +

-

- then T doesn't change m_i results. Here we note that we are evaluating a specific machine m_i, so we must add the qualifier 'm_i results'. It might be that for another machine with another corresponding set of interesting inputs, the transform would lead to a new machine that produces different results. -

+

+ If the domain quantification is over an infinite input space, then the only option for answering a question about properties of such a machine under these conditions is to use a higher-order analysis. Similarly, if the analyzed machine does not halt, the only way to answer questions about properties of such a machine is to use a higher-order analysis on it. +

-

- If, and only if, it is the case that -

+

+ Famously, we know that no analyzer can universally determine whether a machine is computational, i.e. that it halts in a finite number of steps. This was proven by reasoning about, i.e. analyzing, the properties of a hypothetically existing halting analyzer machine. A count of the layers shows that this was a third-order analysis activity. +

- - - - \forall i, \forall j \colon r_{i,j} = r_{i.1,j} - - eq: The same results transform property, over all machines - +

+ All orders of analysis come down to running a machine. There is no difference in architecture between a machine doing first-order analysis and one doing second-order analysis, etc. The order of analysis is only assigned by analyzing the system as a whole, and it exists outside the system, and thus does not affect the computation, so it is merely useful information when discussing the system. However, this would change if this system meta-information were fed back into the system for decisions to be made upon it. +

-

- then we can say without qualification that T is a same results transform. Though still implied are the sets of machines, tapes, and questions. -

+

+ Orders of analysis are not formally constructed from fundamentals. A second-order analysis might be taken up to address a hole that directly running a machine can not fill. However, that doesn't say what order of machine it is that has the hole. That information might be immaterial. Hence, discussions of orders of analysis are bubbles of meaning, rather than constructed pyramids of meaning. +

- Definition of the computation theoretic consequential/inconsequential transform property - -

- Suppose we still have the given machines, and their corresponding inputs, that were used when determining transform T is a same results transform. -

- -

- Suppose we also have a computation theory C that allows us to analyze some machines so as to answer some questions we find interesting. Suppose furthermore that among these questions are questions of time and space complexity, along with zero or more questions about decidability. Furthermore, we are given a machine, say m_i, for which these questions have answers. We represent this as: -

- - - - - a_{i,k} = q_{i,k}(m_i, \{x_{i,j}\}) - - eq: A computation theoretic question and the answer it has for a machine - - -

- Here, \{x_{i,j}\} represents the entire domain of j tapes being passed as arguments to the question q_{i,k}. From this, we can observe that if there are n_k questions, then we will have n_k answers. Also, for a specific machine m_i, where there are n_j j values, the domain over which m_i will be analyzed will have n_j tapes in it. -

- -

- As we had already discovered when determining T is a same results transform, T transforms machine m_i into machine m_{i.1}. -

- - - - - m_i \xrightarrow{T} m_{i.1} - - eq: Transform T carries machine m_i to machine m_{i.1}, restated - - -

- For our specific machine m_i, if and only if: -

- - - - - \forall k \colon a_{i,k} = a_{i.1,k} - - eq: The inconsequential condition for one machine - - -

- then T is computation theoretic inconsequential for m_i. -

+ Definition of the same results transform property -

- If, and only if, it is the case that: -

+

+ Suppose we are given a Turing Machine m_i, which will potentially be run after being given any one of a number of input tapes x_{i,j}. For each of those inputs, the same tape with the results written upon it will be r_{i,j}. We notate this as: +

+ + + + + m_i(x_{i,j}) = r_{i,j} + + eq: Machine m_i given input tape x_{i,j} writes result tape r_{i,j} + + +

+ Here the subscripts of the same name set up a correspondence. x_{i,j} is the jth input to the machine m_i, etc. The free variable j runs over all the interesting distinct input tapes to be given to machine m_i. So for example, if we had a machine, say m_8, and we had a set of three inputs to be given to m_8, then: +

+ + + + + \begin{aligned} + m_8(x_{8,0}) &= r_{8,0} \\ + m_8(x_{8,1}) &= r_{8,1} \\ + m_8(x_{8,2}) &= r_{8,2} + \end{aligned} + + eq: Machine m_8 over a set of three input tapes + + +

+ Another machine, perhaps machine m_7, would have its own distinct inputs x_{7,j}, etc. +

+ +

+ Now suppose that a machine m_{i.1} is the result of a transformation, T, applied to machine m_i. +

+ + + + + m_i \xrightarrow{T} m_{i.1} + + eq: Transform T carries machine m_i to machine m_{i.1} + + +

+ We can then assign a property to transform T called its doesn't change results property, as follows. If and only if: +

+ + + + + \forall j \colon r_{i,j} = r_{i.1,j} + + eq: The doesn't change results condition for one machine + + +

+ then T doesn't change m_i results. Here we note that we are evaluating a specific machine m_i, so we must add the qualifier 'm_i results'. It might be that for another machine with another corresponding set of interesting inputs, the transform would lead to a new machine that produces different results. +

+ +

+ If, and only if, it is the case that +

+ + + + + \forall i, \forall j \colon r_{i,j} = r_{i.1,j} + + eq: The same results transform property, over all machines + + +

+ then we can say without qualification that T is a same results transform. Though still implied are the sets of machines and tapes. +

- - - - \forall i, \forall k \colon a_{i,k} = a_{i.1,k} - - eq: The computation theoretic inconsequential transform property - + -

- then we can say without qualification that T is computation theoretic inconsequential. Though still implied are the sets of machines and tapes. -

+ + Definition of the computation theoretic consequential and inconsequential transform property + +

+ Suppose we still have the given machines, and their corresponding inputs, that were used when determining that transform T is a same results transform. +

+ +

+ Suppose we also have a computation theory C that allows us to analyze some machines so as to answer some questions we find interesting. Suppose furthermore that among these questions are questions of time and space complexity, along with zero or more questions about decidability. Furthermore, we are given a machine, say m_i, for which these questions have answers. We represent this as: +

+ + + + + a_{i,k} = q_{i,k}(m_i, \{x_{i,j}\}) + + eq: A computation theoretic question and the answer it has for a machine + + +

+ Here, \{x_{i,j}\} represents the entire domain of j tapes being passed as arguments to the question q_{i,k}. From this, we can observe that if there are n_k questions, then we will have n_k answers. Also, for a specific machine m_i, where there are n_j j values, the domain over which m_i will be analyzed will have n_j tapes in it. +

+ +

+ As we had already discovered when determining that T is a same results transform, T transforms machine m_i into machine m_{i.1}. +

+ + + + + m_i \xrightarrow{T} m_{i.1} + + eq: Transform T carries machine m_i to machine m_{i.1}, restated + + +

+ For our specific machine m_i, if and only if: +

+ + + + + \forall k \colon a_{i,k} = a_{i.1,k} + + eq: The inconsequential condition for one machine + + +

+ then T is computation theoretic inconsequential for m_i. +

+ +

+ If, and only if, it is the case that: +

+ + + + + \forall i, \forall k \colon a_{i,k} = a_{i.1,k} + + eq: The computation theoretic inconsequential transform property + + +

+ then we can say without qualification that T is computation theoretic inconsequential. Though still implied are the sets of machines, tapes, and questions. +

@@ -580,7 +611,7 @@ The conventional Turing Machine -

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

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

@@ -772,7 +803,7 @@ q5 •0 1 1 done • 0 1 1 - Code . A step by step trace of the conventional reverse machine + Code . A step-by-step trace of the conventional reverse machine @@ -798,7 +829,7 @@

Reversing a string does not intrinsically require making decisions based on the values in the string that is being reversed; however, a Turing Machine must use the value under the head for the next-state transitions. Also, the only memory a controller has is through adding control path branches, so to "carry the symbol right" requires a branch in the state controller per symbol to remember what the symbol is. Consequently, had the input alphabet been larger, this controller would have required proportionally more states, as noted on the diagram.

-

For a real machine, symbols are machine word encodings. For example, ASCII uses 7 data bits, so there are 128 symbols available. If the width of the word for encoding symbols is n bits, then the total number of states required for this string reverse machine is:

+

For a realized machine, symbols are machine word encodings. For example, ASCII uses 7 data bits, so there are 128 symbols available. If the width of the word for encoding symbols is n bits, then the total number of states required for this string reverse machine is:

@@ -818,9 +849,9 @@ eq: Arcs required by the conventional reverse machine -

These equations show that the state controller size explodes with word width. It would be impractical to implement for all but the smallest of word sizes. This is one of the reasons that computation theory books use modest-sized symbol alphabets in their examples, perhaps the first few letters of the Latin alphabet, or the letter 's' for unary arithmetic. Previous sections discussed challenges transitioning the Turing Machine to a real architecture due to the tape length, and discussed how this could be mitigated. In contrast, there is no practical mediation for implementing a Turing Machine controller even for modest-sized real problems.

+

These equations show that the state controller size explodes with word width. It would be impractical to implement for all but the smallest of word sizes. This is one of the reasons that computation theory books use modest-sized symbol alphabets in their examples, perhaps the first few letters of the Latin alphabet, or the letter 's' for unary arithmetic. Previous sections discussed challenges transitioning the Turing Machine to a modern architecture due to the tape length, and discussed how this could be mitigated. In contrast, there is no practical mediation for implementing a Turing Machine controller even for modest-sized real problems.

-

This raises a question: if the Turing machine is to instruct upon the limitations of real computation, what are the implications stemming from its state controller being impractical? As one such implication, when a Turing Machine proof shows that a number is computable, it doesn't necessarily instruct upon how it could be computed. When a reader picks up a text on applied number theory, also called computer arithmetic, he is unlikely to find a chapter on Turing Machines.

+

This raises a question: if the Turing Machine is to instruct upon the limitations of real computation, what are the implications stemming from its state controller being impractical? As one such implication, when a Turing Machine proof shows that a number is computable, it doesn't necessarily instruct upon how it could be computed. When a reader picks up a text on applied number theory, also called computer arithmetic, he is unlikely to find a chapter on Turing Machines.

The observation runs the other way as well. There is not a single chapter dedicated to computation theory in Hennessy and Patterson's definitive textbook on computer architecture. John L. Hennessy and David A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed. (Cambridge: Morgan Kaufmann, 2017).

@@ -839,7 +870,7 @@ Chapter 3 - Instruction Level Parallelism and Its Exploitation + Instruction-Level Parallelism and Its Exploitation Chapter 4 @@ -931,7 +962,7 @@

It is possible to build a mapping between the machine A and machine B. The read and write operations are placed into correspondence. The empty set as a member of tape sequence of machine A is placed into correspondence with the empty symbol of machine B. The other components are defined identically, and map directly. This establishes an isomorphism between the two machines. Hence, they are equally expressive. However, machine B is simpler, so it is understandable that computer theoreticians have settled on this definition.

-

If we view the empty symbol from within the definition of machine B, it is a category error. It is a sequence element rather than a container. Even if it were allowed that a position within a sequence were a container and thus could have the property of being empty, the symbol represents that there is no symbol in the very location it is found. Hence, to ascribe an appropriate meaning to the empty symbol, the entire system must be kept including the mapping to machine A, then the empty symbol found on machine B means that if machine A were used instead, the same location in the tape sequence would be an empty set. However, this feels unsatisfactory, because in all other respects, machine B is a perfectly well defined Turing Machine all by itself.

+

If we view the empty symbol from within the definition of machine B, it is a category error. It is a sequence element rather than a container. Even if it were allowed that a position within a sequence were a container and thus could have the property of being empty, the symbol represents that there is no symbol in the very location it is found. Hence, to ascribe an appropriate meaning to the empty symbol, the entire system must be kept including the mapping to machine A, then the empty symbol found on machine B means that if machine A were used instead, the same location in the tape sequence would be an empty set. However, this feels unsatisfactory, because in all other respects, machine B is a perfectly well-defined Turing Machine all by itself.

Going back to Turing's moniker of blank does limit the focus solely to machine B, because the original paper by Turing states the definition of blank meaning "no symbol", as was already discussed. Calling it blank is merely the same name colored by the engineering of wood pulp. However, there is a pleasing property of the blank, i.e. the empty symbol, that is valuable and unique to it. It prints as a space in diagrams given in text books and in the output of Turing Machine simulators. There is an analogous symbolic system that also has this characteristic, and is being leveraged in these situations: the ASCII hex 20, called SP. It prints as a space leaving an area of the paper it is printed on blank. Perhaps a better name for the ersatz empty symbol is SP.

@@ -941,7 +972,7 @@

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

-

Firstly note that excluding SP from Σ does not prevent a Turing machine from writing SP to a tape to be used as a message. If a message writing machine wants to write an SP to the tape, it merely writes a different symbol then erases it.

+

Firstly note that excluding SP from Σ does not prevent a Turing Machine from writing SP to a tape to be used as a message. If a message writing machine wants to write an SP to the tape, it merely writes a different symbol then erases it.

Secondly, once it is realized that SP symbols can be written to tape as messages, the very reason of excluding it from Γ, to guarantee that received messages are parsable, is lost. A message authoring machine could, for example, happily output a variable length array of strings while using an arbitrary number of empty symbols to separate the elements. A receiving machine could then not know how many elements it should try to recover, or when to say a string of SP symbols is sufficiently long to not be considered a separator. Nothing in the Turing Machine definition prevents this.

@@ -949,7 +980,7 @@

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

-

For the modified computational Turing machine presented later in this chapter, there will be a separate control alphabet of predefined symbols, as for the Hopcroft-Ullman interpretation. However, so as to support recursion, and because the current scheme does not achieve protocol guarantees, the predefined alphabet will be part of the alphabet Σ rather than distinct from it. Programmers then must explicitly design communication protocols that suit the problems they are working on, and those protocols become opaque for examination by a higher authority. Note that this does not preclude a programmer from using SP as an EOM marker, rather it removes the embedding of that protocol from the Turing Machine definition.

+

For the modified computational Turing Machine presented later in this chapter, there will be a separate control alphabet of predefined symbols, as for the Hopcroft-Ullman interpretation. However, so as to support recursion, and because the current scheme does not achieve protocol guarantees, the predefined alphabet will be part of the alphabet Σ rather than distinct from it. Programmers then must explicitly design communication protocols that suit the problems they are working on, and those protocols become opaque for examination by a higher authority. Note that this does not preclude a programmer from using SP as an EOM marker, rather it removes the embedding of that protocol from the Turing Machine definition.

@@ -966,13 +997,13 @@

In the first edition of this book, I introduced a "read-only after write" rule while working towards an architectural Turing Machine because conventional computer architectures do not maintain a concept of empty memory. The approach described in this section integrates the "read-only after write" into a computation theoretic machine by designing in the concept of being unspecified, which then displaces the concept of a cell being empty.

-

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

+

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

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

-

Core memory, and later system memory, was random access and initially fully accessible. The data would be whatever scrambled mess the machine booted with, or in early virtual memory systems, whatever was left over from the prior use of the page. The approach of recycling pages was a security hazard, so today a page is initially allocated from a read-only zero page, and due to a copy-on-write trap, a new page will be created in memory then the original page copied to it, thus scrubbing it with zeros. The zero pointer is in a sense an empty symbol, as an attempt to dereference it will cause a fault. However, on real machines, there are many integer values used, and these can also be zero. Thus the zeros of the new page are not identical to saying the page contains all empty symbols. In this system, the programmer is again burdened with maintaining the "read-only after write" rule. Compilers and interpreters often help with this by attempting to detecting the use of uninitialized data and throwing an error.

+

Core memory, and later system memory, was random access and initially fully accessible. The data would be whatever scrambled mess the machine booted with, or in early virtual memory systems, whatever was left over from the prior use of the page. The approach of recycling pages was a security hazard, so today a page is initially allocated from a read-only zero page, and due to a copy-on-write trap, a new page will be created in memory then the original page copied to it, thus scrubbing it with zeros. The zero pointer is in a sense an empty symbol, as an attempt to dereference it will cause a fault. However, on realized machines, there are many integer values used, and these can also be zero. Thus the zeros of the new page are not identical to saying the page contains all empty symbols. In this system, the programmer is again burdened with maintaining the "read-only after write" rule. Compilers and interpreters often help with this by attempting to detecting the use of uninitialized data and throwing an error.

-

A violation of "read-only after write" could be detected by a modified computation theoretic Turing Machine if, instead of an empty symbol, the initial tape is filled with the unspecified symbol. The end objective is to detect an erroneous condition, which is useful for debugging and testing. Conventionally, mathematicians do not concern themselves with the test and debug phases of programming a Turing Machine, but rather concern themselves with answering computation theoretic questions about known working Turing Machine programs. Though perhaps an algorithm could be analyzed for this very quality of not ever making decisions based on unspecified data. Nor do real machines have an unspecified symbol; rather, a program reads garbage from memory locations with unspecified data. There is precedent for an x, unknown, logic state in hardware simulators.

+

A violation of "read-only after write" could be detected by a modified computation theoretic Turing Machine if, instead of an empty symbol, the initial tape is filled with the unspecified symbol. The end objective is to detect an erroneous condition, which is useful for debugging and testing. Conventionally, mathematicians do not concern themselves with the test and debug phases of programming a Turing Machine, but rather concern themselves with answering computation theoretic questions about known working Turing Machine programs. Though perhaps an algorithm could be analyzed for this very quality of not ever making decisions based on unspecified data. Nor do realized machines have an unspecified symbol; rather, a program reads garbage from memory locations with unspecified data. There is precedent for an x, unknown, logic state in hardware simulators.

Like the empty symbol, unspecified is a meta-symbol. It describes the data, or lack thereof, rather than being the data. Specifically, the unspecified symbol says that another machine, a machine A, would have a singular alphabet symbol at the memory location, but our machine B is not being informed as to which symbol it is. Because the Turing Machine state transition function requires a specific symbol value, reading an unspecified symbol, and then using it to make a decision as though it were a concrete symbol, would be an error, unless that control path was for the very purpose of detecting this error.

@@ -982,7 +1013,7 @@
  1. The memory was not initialized.
  2. The memory holds stale data written by an unrelated process, such as a reused memory allocation.
    3. -
  3. The data is effectively unspecified because the program, by design, does not make decisions based upon its value. +
  4. The data is effectively unspecified because the program, by design, does not make decisions based upon its value.
List . Reasons a memory location can hold an unspecified value @@ -1021,7 +1052,7 @@

Here the subscript i is a device used to emphasize that q_i and q_{i+1} can be any members of the total set of states, Q. State q_0 refers specifically to the initial state. Also note, later the spartan q will be used to denote the contents of the q register, the current state register.

-

The Hopcroft and Ullman machine definition specified a next-state function, δ. Here we instead use next-state tables that cascade, and as tables are containers, we denote these using a capital letter as Δ_0, Δ_1, Δ_2, and Δ_3. +

The Hopcroft and Ullman machine definition specified a next-state function, δ. Here we instead use next-state tables that cascade, and as tables are containers, we denote these using a capital letter as Δ_0, Δ_1, Δ_2, and Δ_3.

The new machine evaluates next-state transitions through these four layers, in order, progressing to the next layer only when no transition is found in the prior layer:

@@ -1180,7 +1211,7 @@ eq: Δ₀, the conditional transition table -

Here q_i and q_{i+1} are two states from the total set of Q. They need not be distinct. While the machine is running, state q_i is to be matched against the contents of the q register, the current state. Symbol σ is a member of the total set Σ and is to be matched against the contents of the s register, the machine status. When q_i matches the current state and σ matches the current status, then q_{i+1} becomes the next-state.

+

Here q_i and q_{i+1} are two states from the total set of Q. They need not be distinct. While the machine is running, state q_i is to be matched against the contents of the q register, the current state. Symbol σ is a member of the total set Σ and is to be matched against the contents of the s register, the machine status. When q_i matches the current state and σ matches the current status, then q_{i+1} becomes the next-state.

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

@@ -1793,9 +1824,9 @@ Code . The two-headed reverse controller written as C -

This machine has a single tape with two heads marking two separate context areas. Because the areas do not overlap, this situation is indistinguishable from the case of the machine having two separate tapes, each with its own head. Hartmanis and Stearns established the original proof that simulating a Turing Machine with multiple tapes, each with its own head, on a single-tape, single-head machine incurs a quadratic time penalty J. Hartmanis and R. E. Stearns, "On the computational complexity of algorithms," Transactions of the American Mathematical Society 117 (1965): 285-306.. Hopcroft and Ullman formalize this relationship in their text John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison Wesley, 1979), 292.. This explains why in this example of a string reverse machine, when the second head was added to eliminate the head shuttling, the quadratic term disappeared. Not all quadratic terms in step-count formulas are due to shuttling, but this one happens to be such a case.

+

This machine has a single tape with two heads marking two separate context areas. Because the areas do not overlap, this situation is indistinguishable from the case of the machine having two separate tapes, each with its own head. Hartmanis and Stearns established the original proof that simulating a Turing Machine with multiple tapes, each with its own head, on a single-tape, single-head machine incurs a quadratic time penalty J. Hartmanis and R. E. Stearns, "On the computational complexity of algorithms," Transactions of the American Mathematical Society 117 (1965): 285-306.. Hopcroft and Ullman formalize this relationship in their text John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison-Wesley, 1979), 292.. This explains why in this example of a string reverse machine, when the second head was added to eliminate the head shuttling, the quadratic term disappeared. Not all quadratic terms in step-count formulas are due to shuttling, but this one happens to be such a case.

-

The time complexity of the longest compute time input of length n dropping from O(n^2) to O(n) is computation theoretic consequential, so we should make a choice as to which machine to use as a reference. Given that real computers have multiple pointers into different memory contexts, the multi-head Turing Machine is the more suitable reference model.

+

The time complexity of the longest compute time input of length n dropping from O(n^2) to O(n) is computation theoretic consequential, so we should make a choice as to which machine to use as a reference. Given that realized computers have multiple pointers into different memory contexts, the multi-head Turing Machine is the more suitable reference model.

Adding heads functions as a specialized optimization rather than a universal method for improving performance complexity. Quadratic performance improvements manifest only under specific conditions. Even when they occur, the improvement remains insufficiently strong to alter the asymptotic performance if higher-order terms exist in the step-count polynomial. Furthermore, eliminating shuttling is structurally incapable of reducing a linear step-count to a constant-time step-count; the reason is that n is unbounded, while adding k heads only divides the work by a fixed constant k. Consequently, while the transformation is consequential in specific cases, it cannot change the broader time complexity class.

@@ -1824,7 +1855,7 @@

The same can be said for space complexity. Suppose a program doubled its memory footprint each time its input string increased by one. If an individual proton could hold one bit of memory, say via its spin, an input increase of merely 270 characters for such a program would exhaust all the protons in the universe. Allocating a cell of space requires the machine to take a step, so time complexity is at least equal to space complexity. If a computer ran at 10 GHz and a step required 10^{-10} seconds, this same extension would require 6 \times 10^{63} years. For perspective, the universe is approximately 1.4 \times 10^{10} years old.

-

This book provides the transformational steps needed to go from the Turing Machine to real machines, and one objective is to recover some correspondence between the machine steps of the model and the wall-clock time the machine takes to run. Given this, the system operator changing tapes creates a step that is disproportionately longer than the other steps, a factor that requires architectural mediation, but will always remain. For example, this structural penalty resurfaces in the form of cache misses causing a machine to reach into system memory, or worse, page faults, requiring a machine to go back to disk.

+

This book provides the transformational steps needed to go from the Turing Machine to realized machines, and one objective is to recover some correspondence between the machine steps of the model and the wall-clock time the machine takes to run. Given this, the system operator changing tapes creates a step that is disproportionately longer than the other steps, a factor that requires architectural mediation, but will always remain. For example, this structural penalty resurfaces in the form of cache misses causing a machine to reach into system memory, or worse, page faults, requiring a machine to go back to disk.

As a possible practical solution, note that if the program does not exhaust the current tape, the operator will never be called. How much tape is required to ensure this? An analyst could choose worst-case operands and measure the footprint when the program runs. At first, this appears to be the familiar 'my number is bigger than your number, I'll tell you mine after you tell me yours' game, which can be viewed as the definition for the countable infinity. However, there is a loophole. Running the system once with the worst-case operands to establish time and space ceilings guarantees the program can be allocated sufficient resources later for other operands. This is a practical approach, provided the program is a workhorse utility rather than an algorithm searching for a solution to an unsolved problem, and thus only needs to be run once.

@@ -1847,7 +1878,7 @@ List . The instructions supported by the head unit controller -

On this model of machine, the HU status is identical to the indicated cell's type. The cell type is not read from the tape; rather, it is derived from the head's physical relationship to the ends of the tape. With a real tape drive, an unused leader and trailer are required to prevent the tape from departing from the reels, a condition difficult to reverse. Therefore, the format, or physical, markers will be on the ends of the usable portion of the tape, rather than on the physical end of the tape. Consequently, the HU works in conjunction with the TTU to derive the status. (The tape transport unit, the TTU, is discussed in the next section, section .) As established in section , cell types are:

+

On this model of machine, the HU status is identical to the indicated cell's type. The cell type is not read from the tape; rather, it is derived from the head's physical relationship to the ends of the tape. With a physical tape drive, an unused leader and trailer are required to prevent the tape from departing from the reels, a condition difficult to reverse. Therefore, the format, or physical, markers will be on the ends of the usable portion of the tape, rather than on the physical end of the tape. Consequently, the HU works in conjunction with the TTU to derive the status. (The tape transport unit, the TTU, is discussed in the next section, section .) As established in section , cell types are:

@@ -2091,7 +2122,7 @@

Then the clock rises, and the cycle repeats, though perhaps while selecting a different row from the instruction table, and thus performing a different instruction.

-

In physical machine design, rather than triggering logic on both edges of a single clock and managing strict duty cycle constraints, designers often deploy two clocks separated by a 180-degree phase shift. This configuration, known as two-phase clocking, allows all registers to sample uniformly on a rising edge (or all on a falling edge) while permitting designers to adjust the phase separation to optimize timing margins. This approach can be used to accommodate any number of phase separated clocks. Alternatively, a single-edge-triggered clock can drive the entire control loop. In this design, the current state propagates through the instruction table, selects the driving status register in the TTU, passes through the status decoder, and resolves at the next-state matrix. Because the s and d registers are wired as appendages to this primary loop and also sample on the rising edge, the system must enforce strict hold-time requirements. This guarantees the registers capture the established state rather than the transient values newly propagating across the bus. Clocking designs that successfully maintain these operational margins across the extremes of manufacturing tolerances and thermal ranges are said to be clean.

+

In physical machine design, rather than triggering logic on both edges of a single clock and managing strict duty cycle constraints, designers often deploy two clocks separated by a 180-degree phase shift. This configuration, known as two-phase clocking, allows all registers to sample uniformly on a rising edge (or all on a falling edge) while permitting designers to adjust the phase separation to optimize timing margins. This approach can be used to accommodate any number of phase separated clocks. Alternatively, a single-edge-triggered clock can drive the entire control loop. In this design, the current state propagates through the instruction table, selects the driving status register in the TTU, passes through the status decoder, and resolves at the next-state matrix. Because the s and d registers are wired as appendages to this primary loop and also sample on the rising edge, the system must enforce strict hold-time requirements. This guarantees the registers capture the established state rather than the transient values newly propagating across the bus. Clocking designs that successfully maintain these opeRational margins across the extremes of manufacturing tolerances and thermal ranges are said to be clean.

@@ -2221,14 +2252,14 @@ - In band and out-of-band control + In-band and out-of-band control

- Because of the impossibility of recognizing certain tape features, when a tape is written by one Turing Machine, then used by another, there must be some sort of system for messaging control. There are two approaches for mixing data and control together: one is in band signaling, while the other is out-of-band signaling. + Because of the impossibility of recognizing certain tape features, when a tape is written by one Turing Machine, then used by another, there must be some sort of system for messaging control. There are two approaches for mixing data and control together: one is in-band signaling, while the other is out-of-band signaling.

- In band control occurs when control signals or structural metadata are mixed directly into the same channel and alphabet as the data payload. In band signaling leads to ambiguities between what is control and what is data. As we saw, there are cases where a recognizer, i.e., merely examining the data, is completely incapable of resolving even the simplest of control questions. A conventional approach for resolving these ambiguities makes use of escape sequence schemes that grow in length as the levels of communication grow. This has always been an afterthought, a sort of hack. + In-band control occurs when control signals or structural metadata are mixed directly into the same channel and alphabet as the data payload. In-band signaling leads to ambiguities between what is control and what is data. As we saw, there are cases where a recognizer, i.e., merely examining the data, is completely incapable of resolving even the simplest of control questions. A conventional approach for resolving these ambiguities makes use of escape sequence schemes that grow in length as the levels of communication grow. This has always been an afterthought, a sort of hack.

@@ -2259,7 +2290,7 @@

A gasket machine is actually a set of subroutines with one corresponding to each of the tape transport instructions. -

+

There is a small problem, in that the left-of-leftmost symbol was stipulated as being separate from the alphabet, and only alphabet symbols and the empty symbol can be written to the tape. There are a couple of possible solutions. One solution is to add a symbol to the alphabet that is also taken to mean 'left of leftmost', say gasket-left-of-leftmost. Then machines that make use of gaskets can recognize this new symbol for its meaning. Another alternative, that will be used for the remainder of our discussion, is to define a separate control alphabet of symbols that are distinct from data alphabet symbols, but can also be written and read from the tape. We will add to this alphabet, empty, left-of-leftmost, and a new control symbol used by gaskets,right-of-rightmost. @@ -2312,7 +2343,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- When discussing symbols we noted they could be natural numbers, and even went so far as to point out that addresses were symbols, though we had not yet defined them. They are familiar to anyone involved in computing, so again, it did not present a serious problem. Here we have now formalized them. + When discussing symbols we noted they could be Natural Numbers, and even went so far as to point out that addresses were symbols, though we had not yet defined them. They are familiar to anyone involved in computing, so again, it did not present a serious problem. Here we have now formalized them.

@@ -2322,7 +2353,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

As we noted in section , an area has two distinguishing features, being that it has a leftmost cell, and a rightmost cell. That definition is topological. If we start with the leftmost cell of a tape, we are either already on the leftmost cell of a defined area, or we can step right to find it. At the point of finding it we know this leftmost cell is part of the area, then we are either already on the rightmost cell, or we can continue to step right on cells in the area until we find the rightmost cell in the area. The right neighbor of the rightmost cell in the area, and all cells to that right of that, are excluded from the area.

-

With addresses we can now define an area with two addresses, two natural numbers, the address of the leftmost cell, and that of the rightmost cell. All natural numbers greater than or equal to the address of the leftmost cell, or less than or equal to the address of the rightmost cell, are addresses of cells that are in the area. This feels more satisfactory for most of us, as now we are talking about arithmetic rather than graph topology. Though should the topology of the tape be generalized, this could become limiting. It reminds me of Frege's admonition that perhaps math should be built on top of geometry. +

With addresses we can now define an area with two addresses, two Natural Numbers, the address of the leftmost cell, and that of the rightmost cell. All Natural Numbers greater than or equal to the address of the leftmost cell, or less than or equal to the address of the rightmost cell, are addresses of cells that are in the area. This feels more satisfactory for most of us, as now we are talking about arithmetic rather than graph topology. Though should the topology of the tape be generalized, this could become limiting. It reminds me of Frege's admonition that perhaps math should be built on top of geometry.

@@ -2346,7 +2377,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

If cells in an area are transacted, the cost of the area is the cost of a cell multiplied by the count of cells. Vincent Atanasoff probably found himself needing to know such a count when ordering capacitors. The count of cells in an area is also known as the area's length. We will use the Greek symbol Ï¡, pronounced as sampi, to refer to the length. The length of an area, the count of its cells, will always be one greater than its extent, Ï¡ = \omega + 1. This symbol makes sense here, as the Greek number system fell short of letters, so the symbol Ï¡ was tacked on to the end of the alphabet, but did not belong to the alphabet.

-

The count of cells in an area, the length of an area, and the cardinality of the address space for an area are all the same number, Ï¡. The extent of an area, \omega, is an address in an area's address space, whereas the cardinality of an area, Ï¡, falls outside it. This has implications. Because extent is an address, extent and addresses can always use the same number representation. In contrast, there is no such guarantee for cardinality, Ï¡. Take for example an area that contains 256 cells. The addresses run from zero to 255, and all can be represented with an 8 bit binary number. However, the number 256 requires 9 bits, and thus would not fit in an 8 bit address register. This one of the reasons that code will have fewer end case problems when expressing the size of objects with extents, rather than with lengths. +

The count of cells in an area, the length of an area, and the cardinality of the address space for an area are all the same number, Ï¡. The extent of an area, \omega, is an address in an area's address space, whereas the cardinality of an area, Ï¡, falls outside it. This has implications. Because extent is an address, extent and addresses can always use the same number representation. In contrast, there is no such guarantee for cardinality, Ï¡. Take for example an area that contains 256 cells. The addresses run from zero to 255, and all can be represented with an 8 bit binary number. However, the number 256 requires 9 bits, and thus would not fit in an 8 bit address register. This one of the reasons that code will have fewer end-case problems when expressing the size of objects with extents, rather than with lengths.

@@ -2379,7 +2410,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos - Lemma 2, cardinality is a natural number + Lemma 2, cardinality is a Natural Number

Cardinality is produced by repeatedly calling the A machine, and the A machine produces Natural Numbers.

@@ -2449,7 +2480,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Size -

Consider the case of a partitioned tape. Then consider that we write a gasket, such that we have a higher level Turing Machine that considers each of the areas of the partition as a cell. So then, initially the Turing machine starts with its head on the leftmost area, stepping right steps to the right neighbor area etc. In this manner we abstract the concept of a cell to areas. A length then becomes a count of areas; however the size remains a count of the cells. Something similar is done in the C language, where the length of an array is a count of the elements in the array, but the size of the array is a count of bytes. A byte being an addressable unit in physical memory, and thus the underlying cell that everything is built up from.

+

Consider the case of a partitioned tape. Then consider that we write a gasket, such that we have a higher level Turing Machine that considers each of the areas of the partition as a cell. So then, initially the Turing Machine starts with its head on the leftmost area, stepping right steps to the right neighbor area etc. In this manner we abstract the concept of a cell to areas. A length then becomes a count of areas; however the size remains a count of the cells. Something similar is done in the C language, where the length of an array is a count of the elements in the array, but the size of the array is a count of bytes. A byte being an addressable unit in physical memory, and thus the underlying cell that everything is built up from.

 @@ -2493,7 +2524,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Charles Burnett published a very interesting book about the translation of Hindu-Arabic mathematics in Europe during the Middle Ages Charles Burnett, Numerals and Arithmetic in the Middle Ages (Farnham: Ashgate Variorum, 2010). DOI: 10.33137/aestimatio.v9i0.25990.. He describes a 9th-century treatise on Hindu-Arabic arithmetic authored by Muḥammad ibn Mūsā al-Khwārizmī, where "al-Khwārizmī" indicated he was from Khwarazm in Central Asia. When this manuscript was translated into Latin in the 12th century, European translators approximated his name as Algoritmi or Algorismi, thus giving us the word algorithm. He notes that the Arabs called such numbers "Indian Numbers". Another chapter, "Why we read Arabic numerals backwards," shows that the little-endian and big-endian debate that has plagued programmers for decades has its origin in the Middle Ages Danny Cohen, "On Holy Wars and a Plea for Peace," IEEE Computer 14, no. 10 (October 1981): 48-54. DOI: 10.1109/C-M.1981.220208.

-

The topological structure of a Hindue-Arabic representation is found embodied in a simple gear based machine called an odometer. Multiple geared wheels occur in a reticulated structure. Pushing a toggle advances the least-significant digit wheel by 36 degrees of rotation. The wheel has a peg in it, such that if it rolls past 9 back to 0, it pushes the toggle on the next wheel in the reticulation sequence. The peg of the last wheel rotates through a toggle that raises the overflow error flag. By its very construction, this process establishes a one-to-one correspondence between each Natural Number and a sequence of symbols in Arabic Representation.

+

The topological structure of a Hindue-Arabic representation is found embodied in a simple gear based machine called an odometer. Multiple geared wheels occur in a reticulated structure. Pushing a toggle advances the least-significant digit wheel by 36 degrees of rotation. The wheel has a peg in it, such that if it rolls past 9 back to 0, it pushes the toggle on the next wheel in the reticulation sequence. The peg of the last wheel rotates through a toggle that raises the overflow error flag. By its very construction, this process establishes a one-to-one correspondence between each Natural Number and a sequence of symbols in Arabic Representation.

@@ -2624,7 +2655,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos The Representation of Zero and Structural Emptiness

In the growing Arabic representation, counting acts as a mechanical mechanism. In the case of zero, before the first increment, the mechanism has not yet encountered a carry-in. At this stage, no digits have materialized in the representation. Any attempt to retrieve a digit in this state results in an access violation.

-

This reveals a fundamental property of Arabic Representation: it encodes both the sequence of digit symbols (which map to a natural number) and the sequence's length (which exists at a meta level, governing computational operations). The representation of zero exposes a limitation. At zero, the representation retains length information necessary for computation but lacks an explicit numerical mapping to zero itself.

+

This reveals a fundamental property of Arabic Representation: it encodes both the sequence of digit symbols (which map to a Natural Number) and the sequence's length (which exists at a meta level, governing computational operations). The representation of zero exposes a limitation. At zero, the representation retains length information necessary for computation but lacks an explicit numerical mapping to zero itself.

Structurally, this forces a design choice between two options:

@@ -2664,7 +2695,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

The first computing machines which performed discrete state computation made use of ten symbols for a digit’s potential values while mimicking how humans perform manual arithmetic. Examples include Pascal’s calculator, Babbage’s machine, the mechanical calculators that came after, Aiken’s Mark computers, and ENIAC.

-

Mechanical machines used physical gears with ten positions, each being 36 degrees apart. An index, such as a metal pointer, pointed at one of the marks, indicating which digit value had been registered on the gear. To change which digit value was registered, the gear turned until the index pointed at the mark corresponding to the desired digit value. Instead of gears, the electronic computer ENIAC used circular shift registers of ten vacuum tube flip-flops. These were called ring counters or decade counters. ENIAC operated on ten-digit signed numbers, so there were ten such ring counters plus a flip-flop for each number. It is structurally important that a person does not conflate the number of available digit values with the length of the digit sequence.

+

Mechanical machines used physical gears with ten positions, each being 36 degrees apart. An index, such as a metal pointer, pointed at one of the marks, indicating which digit value had been registered on the gear. To change which digit value was registered, the gear turned until the index pointed at the mark corresponding to the desired digit value. Instead of gears, the electronic computer ENIAC used circular shift registers of ten vacuum-tube flip-flops. These were called ring counters or decade counters. ENIAC operated on ten-digit signed numbers, so there were ten such ring counters plus a flip-flop for each number. It is structurally important that a person does not conflate the number of available digit values with the length of the digit sequence.

Mechanical machines, such as Howard Aiken’s Mark machines, gated rotational momentum with control linkages and clutches. ENIAC used an electronic analogy to the main rotating shaft: a central pulse clock. Pulses were sent to an electronic gate, and if the control to that gate allowed it, the pulses passed through to the corresponding ring counters to cause each flip-flop in the ring to flip in succession depending on the pulse count.

@@ -2770,7 +2801,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

When a group of eight bits, i.e., an octet, functions as a digit of a number, the arithmetic operates in base 256. Note that octet and octal are distinct concepts. An octet is a group of 8 bits, whereas octal is a number system based on digits that have values running from 0 to 7.

-

Groups of bits become larger. The organization of early RISC microprocessors specified that memory was always moved in groups of 32 bits, called words. Today, address variables are generally 64-bit words, while integer variables are either 32- or 64-bit words. Groups of bits found on internal buses scale larger yet.

+

Groups of bits become larger. The organization of early RISC microprocessors specified that memory was always moved in groups of 32 bits, called words. Today, address variables are generally 64-bit words, while Integer variables are either 32- or 64-bit words. Groups of bits found on internal buses scale larger yet.

Bits are also grouped to construct numbers with bases that are not powers of two. In the BCD code, bits are grouped in fours to form decimal digits.

@@ -2789,7 +2820,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

In BCD, some possible bit value combinations are unused. This is an unavoidable consequence of emulating a number base in binary switch logic when that base is not a power of 2.

-

Octal and hexadecimal operate primarily as writing aids. Internally, the computer computes in binary, i.e., base 2. In contrast, BCD computation relies on the structural encoding boundaries. When two BCD digits are summed, the carry occurs when the sum of two digits reaches ten or more, which does not fall on a power of two boundary.

+

Octal and hexadecimal operate primarily as writing aids. Internally, the computer computes in binary, i.e., base 2. In contrast, BCD computation relies on the structural encoding boundaries. When two BCD digits are summed, the carry occurs when the sum of two digits reaches ten or more, which does not fall on a power-of-two boundary.

Some processors lack native BCD computation, providing BCD to binary conversion operations instead. Consequently, numbers that appear as BCD in memory convert to binary before computation. Other computers, most notably many IBM machines, implement true BCD architectures featuring instructions for directly operating on BCD encoded numbers.

@@ -2826,7 +2857,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos
Figure 10: Left justified, least-significant-digit-first
- Figure . A left justified word holding a number least-significant-digit-first + Figure . A left-justified word holding a number least-significant-digit-first

In Figure , the same number populates the word using big-endian architecture. For all but very large numbers, the digit pointed at by the allocation pointer evaluates to zero. A system continues to scan zeros until reaching either the end of the allocation or the most-significant digit. If it reaches the end of the allocation, the contained number evaluates to zero. Because this is the exact same number shown in Figure , it retains the identical least-significant digit and most-significant digit.

@@ -2846,7 +2877,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

If an unconventional processor loads numbers sequentially as digit streams, the load instruction must possess a mechanism to detect the end of the loaded number, or it must receive the exact length prior to execution. This structural boundary is identical to the existing mechanism for loading character strings, where systems utilize length counts or explicit end terminators.

-

For serial computation utilizing little-endian notation, the processor produces the first digit of the sum immediately after receiving the first digit of the operand. If big-endian is used, the least-significant digit arrives last, forcing the system to buffer the entire number before computing the first digit of the sum. Attempting to load from the far ends of the operands fails because the physical location of the sum's far end remains undefined until the carry propagates. Resolving big-endian serial addition requires implementing signed digit arithmetic.

+

For serial computation utilizing little-endian notation, the processor produces the first digit of the sum immediately after receiving the first digit of the operand. If big-endian is used, the least-significant digit arrives last, forcing the system to buffer the entire number before computing the first digit of the sum. Attempting to load from the far ends of the operands fails because the physical location of the sum's far end remains undefined until the carry propagates. Resolving big-endian serial addition requires implementing signed-digit arithmetic.

@@ -2882,7 +2913,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos
Figure 12: In-address-order byte by byte copy
- Figure . A byte by byte copy performed in address order + Figure . A byte-by-byte copy performed in address order

In the second case, the identical data stream arrives with words serialized as bytes in little-endian order, but the receiving machine is big-endian. The system must reverse the bytes strictly on a word-by-word basis.

@@ -2911,7 +2942,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos TTCA -

The native integer data type for TTCA utilizes a high radix online number system. This number system functions as an extension of online arithmetic. Similar to online arithmetic, it employs serial most-significant-digit-first signed digit arithmetic. In contrast to standard signed arithmetic, the radix scales significantly higher, causing a digit to span at least a byte in length. The numbers are highly scalable, and the architecture mandates an analysis step at compile time to establish rigorous precision requirements and exact range bounds. This process is detailed in the next chapter. The architecture provides explicit conversion instructions to generate alternate number formats.

+

The native Integer data type for TTCA utilizes a high radix online number system. This number system functions as an extension of online arithmetic. Similar to online arithmetic, it employs serial most-significant-digit-first signed-digit arithmetic. In contrast to standard signed arithmetic, the radix scales significantly higher, causing a digit to span at least a byte in length. The numbers are highly scalable, and the architecture mandates an analysis step at compile time to establish rigorous precision requirements and exact range bounds. This process is detailed in the next chapter. The architecture provides explicit conversion instructions to generate alternate number formats.

 @@ -2931,7 +2962,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- An address is sent on a trip through the memory hierarchy to locate the corresponding memory cell, ultimately landing on a memory decoder over a physically implemented memory. Address decoders resemble carry chains, and they also have logarithmic physical evaluation times as word width grows. Hence, a fixed width word holding an address gets decoded in approximately constant-time measured in clock ticks. However, the trip through the memory hierarchy is not negligible. + An address is sent on a trip through the memory hierarchy to locate the corresponding memory cell, ultimately landing on a memory decoder over a physically implemented memory. Address decoders resemble carry chains, and they also have logarithmic physical evaluation times as word width grows. Hence, a fixed-width word holding an address gets decoded in approximately constant-time measured in clock ticks. However, the trip through the memory hierarchy is not negligible.

@@ -2959,7 +2990,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- Let us put this into perspective. Suppose in ancient Roman times that a clock tick for a computer was scaled to be one day long, so that the action involves sending letters rather than variable values. Under this scale, a single nanosecond of real world execution time equates to three days. Suppose a program initiated a read request for a location in memory on the Ides of March, the date when Caesar was assassinated on -0043-03-15. Surely that was a big day for posting letters. Table provides the historical date that the variable value would finally be loaded into the processor, depending on the memory tier being accessed: + Let us put this into perspective. Suppose in ancient Roman times that a clock tick for a computer was scaled to be one day long, so that the action involves sending letters rather than variable values. Under this scale, a single nanosecond of real-world execution time equates to three days. Suppose a program initiated a read request for a location in memory on the Ides of March, the date when Caesar was assassinated on -0043-03-15. Surely that was a big day for posting letters. Table provides the historical date that the variable value would finally be loaded into the processor, depending on the memory tier being accessed:

@@ -2969,7 +3000,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Memory Tier - Real World Latency + Real-World Latency Scaled Delay Scaled Arrival Era Historical Context @@ -3026,7 +3057,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos The Universal Turing Machine -

The Computer Theoretic model chapter provided symbolic definitions for the Turing machine and the TTCA variation. Those definitions were written as strings of characters, which the reader scanned, and presumably understood, thus demonstrating the ability of those text strings to convey meaning. Furthermore the text explained in detail how an executor could make use of those definitions so as to perform the input string transformations. As Turing originally noted, the executor could be a person. Alternatively, as the book continued on to describe in detail, the executor could be a machine that applied the input transformations automatically.

+

The Computer Theoretic model chapter provided symbolic definitions for the Turing Machine and the TTCA variation. Those definitions were written as strings of characters, which the reader scanned, and presumably understood, thus demonstrating the ability of those text strings to convey meaning. Furthermore the text explained in detail how an executor could make use of those definitions so as to perform the input string transformations. As Turing originally noted, the executor could be a person. Alternatively, as the book continued on to describe in detail, the executor could be a machine that applied the input transformations automatically.

In his original paper Alan Turing put these things together and explained that a Universal Turing Machine could read the definition of a Turing Machine from tape, and thus be a Turing Machine executor. Hence, say, a Turing Machine reads the symbolic definition of a Turing Machine from one tape, and then automatically performs the described input string transformations on another tape. Said Universal Turing Machine would then be chameleon-like, performing the function of any other Turing Machine so described on the first tape.

@@ -3182,7 +3213,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Symbol in computing

- In the context of real machines, the symbol itself can be defined as a factory that produces symbol instances. A new symbol instance of the given symbol is then made, say, by calling the factory's make function. All of the symbol instances made by the factory constitute the members of the corresponding equivalence class. + In the context of realized machines, the symbol itself can be defined as a factory that produces symbol instances. A new symbol instance of the given symbol is then made, say, by calling the factory's make function. All of the symbol instances made by the factory constitute the members of the corresponding equivalence class.

@@ -3205,7 +3236,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- Though symbol instances are integer like in that copy and equality comparison operations can be used with them, symbol instances are disallowed from being used with other integer operators. Symbols cannot be compared for greater than or less than; they cannot be incremented, added, nor subtracted, etc. + Though symbol instances are Integer like in that copy and equality comparison operations can be used with them, symbol instances are disallowed from being used with other Integer operators. Symbols cannot be compared for greater than or less than; they cannot be incremented, added, nor subtracted, etc.

@@ -3226,7 +3257,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- An alternative implementation is to have the factory return an integer value. Each factory has a base integer that is distinct from that of other factories. Calling make then returns the base integer. + An alternative implementation is to have the factory return an Integer value. Each factory has a base Integer that is distinct from that of other factories. Calling make then returns the base Integer.

@@ -3261,7 +3292,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Symbol copy consequentiality

- Copying symbol instances is an integral part of the operation of the Turing machine. Typically the programmed control steps are used as a cost metric for running a program. Such steps integrate operations of copying symbols to and from the tape. Thus from a pure step-count perspective the cost of the symbol copy is inconsequential, not due to any behavior of a symbol copy, but rather due to the symbol copy being subsumed within the definition of the step. + Copying symbol instances is an integral part of the operation of the Turing Machine. Typically the programmed control steps are used as a cost metric for running a program. Such steps integrate operations of copying symbols to and from the tape. Thus from a pure step-count perspective the cost of the symbol copy is inconsequential, not due to any behavior of a symbol copy, but rather due to the symbol copy being subsumed within the definition of the step.

@@ -3273,7 +3304,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- On a real machine, the factory would be used to make the data alphabet and a couple of additional symbols. As these are set up before the machine runs, and thus before we count steps, these actions are computationally inconsequential. + On a realized machine, the factory would be used to make the data alphabet and a couple of additional symbols. As these are set up before the machine runs, and thus before we count steps, these actions are computationally inconsequential.

@@ -3284,7 +3315,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

An alphabet is another name for 'a set of symbols'. Because it is simply a set, an infinite number of distinct alphabets can exist, and a set of symbols could be finite or infinite.

-

For a Turing machine there are a fixed number of alphabets that are all finite. The set of data symbols, control symbols, and controller state name symbols, are all finite and set in advance. +

For a Turing Machine there are a fixed number of alphabets that are all finite. The set of data symbols, control symbols, and controller state name symbols, are all finite and set in advance.

@@ -3293,7 +3324,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Symbol implementation examples

- The enum of C is used to make alphabets of named symbols. Each entry in the enum is a static symbol factory, and instances are distinct integers. + The enum of C is used to make alphabets of named symbols. Each entry in the enum is a static symbol factory, and instances are distinct Integers.

@@ -3321,7 +3352,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- The enum is a static alphabet made by the compiler, where symbol instances are integers. In the following example, the alphabet is made dynamically, where each symbol instance is a string pointer. + The enum is a static alphabet made by the compiler, where symbol instances are Integers. In the following example, the alphabet is made dynamically, where each symbol instance is a string pointer.

@@ -3408,9 +3439,9 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Dictionary and reference -

A dictionary is a property context object. It is a set of properties, where a property may be selected from the set given its name, which is a symbol instance. The corresponding property value is then the referenced object.

+

A dictionary is a property context object. It is a set of properties, where a property may be selected from the set given its name, which is a symbol instance. The corresponding property value is then the referenced object.

-

A reference is a dictionary key which uniquely identifies a property in the dictionary. A dictionary is also known as a symbol table. In hardware design, the symbols are often unsigned integers, AKA Natural Numbers, and a symbol table is implemented using an array that is indexed into using the key.

+

A reference is a dictionary key which uniquely identifies a property in the dictionary. A dictionary is also known as a symbol table. In hardware design, the symbols are often unsigned Integers, AKA Natural Numbers, and a symbol table is implemented using an array that is indexed into using the key.

Any programming object that holds other objects is a container, whereas a dictionary is a specific type of key access container.

@@ -3453,7 +3484,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- An empty tape is filled with empty symbols. However, as we noted above, a Turing Machine cannot visit all the cells on a tape, so a Turing Machine cannot erase a tape in advance for another Turing Machine to use. Say a Turing Machine tried to erase a tape by writing the empty symbol, then stepping right, then repeating. At some point it must halt. When it halts some number of cells will have been written with the empty symbols, but there will be further cells to the right of the cell the machine halted at, which have not yet been erased. So for example, if a machine wrote 10 cells with the empty symbol, then it might be the case that the prior user of the tape had written data to 11 of the cells. Without historical knowledge the eraser machine can not know where to stop. So here we see another meaning of infinity, it speaks to the situation of not having historical knowledge. And thus, we are left to decree into existence an empty tape, or as the mathematicians say, empty tapes are available by definition. + An empty tape is filled with empty symbols. However, as we noted above, a Turing Machine cannot visit all the cells on a tape, so a Turing Machine cannot erase a tape in advance for another Turing Machine to use. Say a Turing Machine tried to erase a tape by writing the empty symbol, then stepping right, then repeating. At some point it must halt. When it halts some number of cells will have been written with the empty symbols, but there will be further cells to the right of the cell the machine halted at, which have not yet been erased. So for example, if a machine wrote 10 cells with the empty symbol, then it might be the case that the prior user of the tape had written data to 11 of the cells. Without historical knowledge the eraser machine can not know where to stop. So here we see another meaning of infinity, it speaks to the situation of not having historical knowledge. And thus, we are left to decree into existence an empty tape, or as the mathematicians say, empty tapes are available by definition.

@@ -3506,7 +3537,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos second-order Arithmetic

- In their 1990 paper, "Exact Real Arithmetic: Formulating Real Numbers as Functions," Hans-Juergen Boehm and Robert Cartwright presented a system using Turing Machines to represent 'constructive real numbers', or exact real arithmetic. This directly implements a core concept from Alan Turing's 1936 paper of the "computable number." Hans-J. Boehm and Robert Cartwright, "Exact Real Arithmetic: Formulating Real Numbers as Functions," in Design and Implementation of Symbolic Computation Systems (Berlin: Springer, 1990), 43 52. Boehm translated this computation theory into a practical software architecture. Instead of storing a real number as a fixed width floating point approximation, Boehm's system represents a real number as a lazy evaluation function. + In their 1990 paper, "Exact Real Arithmetic: Formulating Real Numbers as Functions," Hans-Juergen Boehm and Robert Cartwright presented a system using Turing Machines to represent 'constructive real numbers', or exact real arithmetic. This directly implements a core concept from Alan Turing's 1936 paper of the "computable number." Hans-J. Boehm and Robert Cartwright, "Exact Real Arithmetic: Formulating Real Numbers as Functions," in Design and Implementation of Symbolic Computation Systems (Berlin: Springer, 1990), 43 52. Boehm translated this computation theory into a practical software architecture. Instead of storing a real number as a fixed-width floating-point approximation, Boehm's system represents a real number as a lazy evaluation function.

@@ -3533,7 +3564,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos (write s) (step) )) - Code . The abstract syntax tree for the natural number five + Code . The abstract syntax tree for the Natural Number five

Similarly, the AST for the number 3:

@@ -3548,7 +3579,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos (write s) (step) )) - Code . The abstract syntax tree for the natural number three + Code . The abstract syntax tree for the Natural Number three

@@ -3595,7 +3626,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Code . A composer that subtracts by inverting the direction of one machine -

We pass our two natural number ASTs to this composer, and we get as a result a newly synthesized AST.

+

We pass our two Natural Number ASTs to this composer, and we get as a result a newly synthesized AST.

@@ -3629,7 +3660,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- For a program containing branched control logic, the simplifier would require a deep recursive walk of the AST to ensure operations aren't annihilated across conditional boundaries. For our explicit natural number generators, a linear scan of the progn body suffices. It calls itself recursively until the scan fails to find any further reductions, returning its optimized AST. + For a program containing branched control logic, the simplifier would require a deep recursive walk of the AST to ensure operations aren't annihilated across conditional boundaries. For our explicit Natural Number generators, a linear scan of the progn body suffices. It calls itself recursively until the scan fails to find any further reductions, returning its optimized AST.

@@ -3703,7 +3734,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- The IEEE 754 floating point standard includes error algebra tags. These are explored in depth by Popova, Evgenija D. "On a Formally Correct Implementation of IEEE Computer Arithmetic." Journal of Universal Computer Science 1, no. 7 (1995): 560 569. This is a form of second-order arithmetic, because each of the error tags is standing in for a machine that did not complete. When a computation fails to result in a first-order object, this becomes a gateway for replacing the result with a second-order object. + The IEEE 754 floating-point standard includes error algebra tags. These are explored in depth by Popova, Evgenija D. "On a Formally Correct Implementation of IEEE Computer Arithmetic." Journal of Universal Computer Science 1, no. 7 (1995): 560 569. This is a form of second-order arithmetic, because each of the error tags is standing in for a machine that did not complete. When a computation fails to result in a first-order object, this becomes a gateway for replacing the result with a second-order object.

@@ -3914,7 +3945,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- Because the binomial coefficient \binom{\omega}{j} evaluates to exactly zero for any integer j > \omega, the summation naturally truncates at index \omega. This algebraic property perfectly mirrors the physical boundary established by the machine execution trace. Furthermore, the relationship is symmetric. A person can compute the specific components of the initial tape, D_{0, n}, directly from the sequence of evaluated function calls, D_{k, 0}, using the alternating binomial sum: + Because the binomial coefficient \binom{\omega}{j} evaluates to exactly zero for any Integer j > \omega, the summation naturally truncates at index \omega. This algebraic property perfectly mirrors the physical boundary established by the machine execution trace. Furthermore, the relationship is symmetric. A person can compute the specific components of the initial tape, D_{0, n}, directly from the sequence of evaluated function calls, D_{k, 0}, using the alternating binomial sum:

@@ -3968,7 +3999,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- Once a_3 is known, the shifting nature of the lower order constants becomes apparent through back substitution. The second difference equation expands to D_{0,2} = 2a_2 + 6a_3. Substituting the known a_3 allows recovery of a_2 = (D_{0,2} - 6a_3) / 2. Similarly, the first difference equation expands to D_{0,1} = a_1 + a_2 + a_3, which resolves to a_1 = D_{0,1} - a_2 - a_3. Through all of this shifting, a_0 = D_{0,0} remains entirely unperturbed. + Once a_3 is known, the shifting nature of the lower-order constants becomes apparent through back substitution. The second difference equation expands to D_{0,2} = 2a_2 + 6a_3. Substituting the known a_3 allows recovery of a_2 = (D_{0,2} - 6a_3) / 2. Similarly, the first difference equation expands to D_{0,1} = a_1 + a_2 + a_3, which resolves to a_1 = D_{0,1} - a_2 - a_3. Through all of this shifting, a_0 = D_{0,0} remains entirely unperturbed.

@@ -4016,7 +4047,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- A pattern emerges. Because each successive forward difference operator annihilates the lowest power of t, the resulting algebraic system is upper triangular. For any extent \omega, the \omegath difference equation reduces to D_{0,\omega} = \omega! a_\omega. This structural guarantee permits a person to reliably recover a_\omega = D_{0,\omega} / \omega!. Because an initial tape of extent \omega dictates that D_{0,\omega} is nonzero, a_\omega is guaranteed to be nonzero. All subsequent lower order constants are then systematically resolved through cascading back substitution. + A pattern emerges. Because each successive forward difference operator annihilates the lowest power of t, the resulting algebraic system is upper triangular. For any extent \omega, the \omegath difference equation reduces to D_{0,\omega} = \omega! a_\omega. This structural guarantee permits a person to reliably recover a_\omega = D_{0,\omega} / \omega!. Because an initial tape of extent \omega dictates that D_{0,\omega} is nonzero, a_\omega is guaranteed to be nonzero. All subsequent lower-order constants are then systematically resolved through cascading back substitution.

@@ -4154,11 +4185,11 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

If we desire to compose recurrence functions, in the first-order or the second-order, the call counts must first be synchronized.

-

Say for example, we have a machine called fizz that adds 3 to the input on the tape, and another machine called buzz that adds 5 to the input on the tape, and we wanted to compose the two machines. We would have to define what a call to the resultant machine means to the machines in composition.

+

Say for example, we have a machine called fizz that adds 3 to the input on the tape, and another machine called buzz that adds 5 to the input on the tape, and we wanted to compose the two machines. We would have to define what a call to the resultant machine means to the machines in composition.

If one call to the resultant machine makes the equivalent of one call to the fizz, and one to buzz, the the resultant machine can be simplified to add 8 to its input tape each time it is called. In contrast if one call to the resultant machine makes the equivalent of 5 calls to fizz, and 3 calls to buzz, then the resultant machine reduces to adding 30 to the input tape per call. The two machines are very different.

-

Performing operations with recurrence functions requires integrating a call algebra in addition to integrating the machines. Often this is handled by considering the machines being composed to be subroutines, and the outer controller than explicitly calls them. The call algebra can then be dynamic depending on the input. Calls can be skipped due to being inside conditionals, or performed an arbitrary number of times in loops. Though simple control structures that are static are more math like, and are more likely to be more affected by optimizations (simplifications).

+

Performing operations with recurrence functions requires integrating a call algebra in addition to integrating the machines. Often this is handled by considering the machines being composed to be subroutines, and the outer controller than explicitly calls them. The call algebra can then be dynamic depending on the input. Calls can be skipped due to being inside conditionals, or performed an arbitrary number of times in loops. Though simple control structures that are static are more math like, and are more likely to be more affected by optimizations (simplifications).

@@ -4366,7 +4397,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- So the value of h(5) is transcendental, but all the machinery we were using, up until using L'Hôpital evaluator, was closed over the rational field. That is why no matter how we tried to organize the difference tables, there was no way to find h(5), or to find a D table for extending through it. This situation occurred due to introducing the 2^t function. Had we remained with finite length D tables, i.e. finite degree polynomials, we could have used deconvolution of the D_0 vectors, or synthetic division on the polynomials, to create the quotient. + So the value of h(5) is transcendental, but all the machinery we were using, up until using L'Hôpital evaluator, was closed over the Rational field. That is why no matter how we tried to organize the difference tables, there was no way to find h(5), or to find a D table for extending through it. This situation occurred due to introducing the 2^t function. Had we remained with finite length D tables, i.e. finite degree polynomials, we could have used deconvolution of the D_0 vectors, or synthetic division on the polynomials, to create the quotient.

@@ -4461,16 +4492,16 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Hans J. Boehm and Robert Cartwright's work of expanding the precision of a computation on demand continued to mature. Boehm, while working at Google, authored a Java constructive reals library that powers the bundled Android calculator. When a person types in an expression, the system builds an Abstract Syntax Tree (AST) of the expression. The display interface determines how many digits fit on the screen and demands exactly that much precision from the root of the tree. The root function then recursively demands progressively higher precision from its operand functions until it achieves the strict error bounds required to guarantee every digit displayed on the screen is mathematically correct Hans J. Boehm, "Small data computing: Correct calculator arithmetic," Google Research, 2015. This library uses constructive real arithmetic to guarantee fully accurate results through demand driven evaluation..

-

Wolfram Mathematica utilizes a true second-order computation system by keeping expressions in their exact symbolic form for as long as possible. An expression like Sqrt[2] + Pi remains an AST of symbols. It then relies on an extensive library of algebraic rewrite rules to simplify the tree. However, unlike Boehm and Cartwright's method of pulling precision through back propagating extension calls, when a numeric result is required, Mathematica runs the computation forward using significance arithmetic. Should there be insufficient precision at the result, it employs an adaptive retry loop Fredrik Johansson, "The significance of arithmetic," 2008. Mathematica implements significance arithmetic by approximating numbers as a floating point value with an attached error estimate, allowing dynamic adaptation and iteration if precision falls below the required threshold. See also: Wolfram Language Documentation, "Arbitrary Precision Numbers" (https://reference.wolfram.com/language/tutorial/ArbitraryPrecisionNumbers.html).. +

Wolfram Mathematica utilizes a true second-order computation system by keeping expressions in their exact symbolic form for as long as possible. An expression like Sqrt[2] + Pi remains an AST of symbols. It then relies on an extensive library of algebraic rewrite rules to simplify the tree. However, unlike Boehm and Cartwright's method of pulling precision through back propagating extension calls, when a numeric result is required, Mathematica runs the computation forward using significance arithmetic. Should there be insufficient precision at the result, it employs an adaptive retry loop Fredrik Johansson, "The significance of arithmetic," 2008. Mathematica implements significance arithmetic by approximating numbers as a floating-point value with an attached error estimate, allowing dynamic adaptation and iteration if precision falls below the required threshold. See also: Wolfram Language Documentation, "Arbitrary Precision Numbers" (https://reference.wolfram.com/language/tutorial/ArbitraryPrecisionNumbers.html)..

The approach I used differs from both of these approaches. Like them, the first step is to build the AST, but then the tree is evaluated in two phases. The first phase analyzes the tree, while creating error propagation expressions either per computation step or for atomic computation blocks. These take the form of symbolic expressions with error \epsilon in and error δ out, over the domain of the input. Then instead of back propagation of precision requests at run time, there is a back propagation of precision requirements at analysis time. This approach was used on the AMD K5 processor transcendental microcode to guarantee that computations yielded specified accuracy. The method is also well suited for setting the bus widths for application specific processors, because the analysis step can occur once at design time. Thomas Walker Lynch, A. Ahmed, M. Schulte, T. Callaway, and R. Tisdale, "The K5 Transcendental Functions," Proceedings of the 12th IEEE Symposium on Computer Arithmetic, 1995. DOI: 10.1109/ARITH.1995.465368. Thomas Walker Lynch, "Numerical Analysis of Computer Approximations," September 2018. DOI: 10.13140/RG.2.2.10906.49601. License CC BY 4.0. https://www.researchgate.net/publication/329402329_Numerical_Analysis_of_Computer_Approximations.

-

None of these computation systems, that of Boehm and Cartwright, Mathematica, nor my error analysis approach, makes use of the IEEE 754 standard floating point arithmetic. Rather they all require the use of variable precision. In the case of Boehm and Cartwright's this occurs through the serialization implied through lazy calls for more precision. In the case of Mathematica it is explicit in the significance arithmetic. In my error analysis approach, the means for variable precision was the High Radix Online Arithmetic Thomas W. Lynch, "High Radix On Line Arithmetic for Credible and Accurate Computing," Real Numbers and Computers, École des Mines de Saint Étienne, France, 1995, pp. 78 89. Thomas W. Lynch and Michael J. Schulte, "Software for High Radix On Line Arithmetic," Reliable Computing, vol. 2, no. 2, 1996, pp. 133 138. DOI: 10.1007/BF02425915.. +

None of these computation systems, that of Boehm and Cartwright, Mathematica, nor my error analysis approach, makes use of the IEEE 754 standard floating-point arithmetic. Rather they all require the use of variable precision. In the case of Boehm and Cartwright's this occurs through the serialization implied through lazy calls for more precision. In the case of Mathematica it is explicit in the significance arithmetic. In my error analysis approach, the means for variable precision was the High Radix Online Arithmetic Thomas W. Lynch, "High Radix On Line Arithmetic for Credible and Accurate Computing," Real Numbers and Computers, École des Mines de Saint Étienne, France, 1995, pp. 78 89. Thomas W. Lynch and Michael J. Schulte, "Software for High Radix On Line Arithmetic," Reliable Computing, vol. 2, no. 2, 1996, pp. 133 138. DOI: 10.1007/BF02425915..

-

Hence what would be useful for a replacement of the IEEE 754, would be a variable precision number standard. There is one being proposed by John Gustafson called the Posit number representation John L. Gustafson, The End of Error: Unum Computing, Chapman and Hall/CRC, 2015. Posits serve as a hardware friendly alternative to IEEE 754 floating point numbers, providing variable precision mechanics.. +

Hence what would be useful for a replacement of the IEEE 754, would be a variable precision number standard. There is one being proposed by John Gustafson called the Posit number representation John L. Gustafson, The End of Error: Unum Computing, Chapman and Hall/CRC, 2015. Posits serve as a hardware friendly alternative to IEEE 754 floating-point numbers, providing variable precision mechanics..

This section reviewed finite difference methods as a means to implement function extensions. A person should notice that finite differences are one among many methods for extending functions, and they are not always the best choice. In modern computing it is not common to implement function extensions. Rather it is more common to increment a value across a domain, while completely repeating the evaluation for each new domain value, for example when computing values to place on a plot. However, independent of their importance in applied computing, function extension and difference methods are of theoretical importance for analysis, particularly when applied to nonstandard analysis. These concepts speak directly to the thesis of computational naturalism—deriving mathematics from computational logic—rather than merely proposing practical methods for implementing software. @@ -4490,7 +4521,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Does computation theory matter to computing?

- Let us put this into perspective. Suppose in ancient Roman times that a clock tick for a computer was scaled to be one day long. Under this scale, a single nanosecond of real world execution time equates to three days. Suppose a program initiated a read request for a location in memory on the Ides of March, the date when Caesar was assassinated on 0043-03-15. Table provides the historical date that the variable value would finally be loaded into the processor, depending on the memory tier being accessed: + Let us put this into perspective. Suppose in ancient Roman times that a clock tick for a computer was scaled to be one day long. Under this scale, a single nanosecond of real-world execution time equates to three days. Suppose a program initiated a read request for a location in memory on the Ides of March, the date when Caesar was assassinated on 0043-03-15. Table provides the historical date that the variable value would finally be loaded into the processor, depending on the memory tier being accessed:

@@ -4500,7 +4531,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Memory Tier - Real World Latency + Real-World Latency Scaled Delay Scaled Arrival Era Historical Context @@ -4559,11 +4590,11 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- The primary data structure of Lisp is the list, and its programs are designed fundamentally around list traversal. In this sense, the language closely mirrors the pure formal execution of a Turing Machine. Throughout the 1980s, companies such as Symbolics, Lisp Machines Incorporated, Texas Instruments, and Xerox produced computers based on architectures designed specifically to run Lisp natively. However, when Sun Microsystems introduced their workstations, the industry discovered these general purpose machines were relatively inexpensive and offered higher performance for the exact same Lisp programs. The commercial mandate to execute programs quickly decisively defeated formal architectural purity. + The primary data structure of Lisp is the list, and its programs are designed fundamentally around list traversal. In this sense, the language closely mirrors the pure formal execution of a Turing Machine. Throughout the 1980s, companies such as Symbolics, Lisp Machines Incorporated, Texas Instruments, and Xerox produced computers based on architectures designed specifically to run Lisp natively. However, when Sun Microsystems introduced their workstations, the industry discovered these general-purpose machines were relatively inexpensive and offered higher performance for the exact same Lisp programs. The commercial mandate to execute programs quickly decisively defeated formal architectural purity.

- A counterexample to this trend occurred during the 1980s when two competing floating point standards emerged. The proposal from DEC allowed for optimally fast computation provided the behavior was well documented. Under this model, the bottom few bits of a computation could be imprecise, and following an interrupt, a program would be required to do diagnostic work to determine the specific instruction that caused the fault. The reasoning was that floating point computation is approximate by its very nature, and because end case interrupts occur infrequently, it makes no sense to sacrifice performance on workhorse computations to accelerate rare anomalies. + A counterexample to this trend occurred during the 1980s when two competing floating-point standards emerged. The proposal from DEC allowed for optimally fast computation provided the behavior was well documented. Under this model, the bottom few bits of a computation could be imprecise, and following an interrupt, a program would be required to do diagnostic work to determine the specific instruction that caused the fault. The reasoning was that floating-point computation is approximate by its very nature, and because end-case interrupts occur infrequently, it makes no sense to sacrifice performance on workhorse computations to accelerate rare anomalies.

@@ -4602,7 +4633,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- Where Gödel reduced logic to natural numbers, we go the other direction to expand upon logic from natural numbers. + Where Gödel reduced logic to Natural Numbers, we go the other direction to expand upon logic from Natural Numbers.

@@ -4630,7 +4661,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- Russell's set formulation, R, can be analyzed to determine that it would not halt if it were run. We still keep it as a second-order object, and have even given it a name, R. However, this begs the question, are there machines that cannot even be analyzed in the second-order to ascertain if they would return a result in first-order analysis, i.e., when they are run? If Gödel has a say here, a person would wager that such machines exist. But then, is there an option for analysis in the third order? Is Turing's halting proof a third order analysis as it reasons about running the second-order analyzer? Or is it merely a recursive application of second-order analysis? + Russell's set formulation, R, can be analyzed to determine that it would not halt if it were run. We still keep it as a second-order object, and have even given it a name, R. However, this begs the question, are there machines that cannot even be analyzed in the second-order to ascertain if they would return a result in first-order analysis, i.e., when they are run? If Gödel has a say here, a person would wager that such machines exist. But then, is there an option for analysis in the third-order? Is Turing's halting proof a third-order analysis as it reasons about running the second-order analyzer? Or is it merely a recursive application of second-order analysis?

@@ -4693,7 +4724,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

- In the Turing Machine architecture, the polynomial coefficients a_i represent the abstract continuous function. The initial tape components D_{0, k} represent the discrete physical realization of that function. Because the Turing Machine operates in discrete integer steps, mapping the abstract polynomial onto the physical tape forces the conversion from standard powers to falling factorials. This is why S(n,k) governs the upper triangular matrix in the preceding lemma. + In the Turing Machine architecture, the polynomial coefficients a_i represent the abstract continuous function. The initial tape components D_{0, k} represent the discrete physical realization of that function. Because the Turing Machine operates in discrete Integer steps, mapping the abstract polynomial onto the physical tape forces the conversion from standard powers to falling factorials. This is why S(n,k) governs the upper triangular matrix in the preceding lemma.

@@ -4737,7 +4768,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos -