From: Thomas Walker Lynch Date: Fri, 7 Aug 2026 09:55:28 +0000 (+0000) Subject: . X-Git-Url: https://git.reasoningtechnology.com/%27%20%20%20full_path%20%20%20%27?a=commitdiff_plain;h=455c5bb44a7fcb9104b6fb3403d1c4cfad57a1b2;p=TM-2026 . --- diff --git a/document/book/TM-2026.html b/document/book/TM-2026.html index 0bec940..45f69c8 100644 --- a/document/book/TM-2026.html +++ b/document/book/TM-2026.html @@ -12,23 +12,30 @@ + - + + - Preface + + Preface

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

Generally in this book, containers such as sequences and sets are capital letters, even when in Greek. Mathematical objects that are not containers are represented with lower case letters. Character pairs or full symbol names can also be used to represent mathematical objects. The context will make it clear if a non-letter unicode character is used to represent a container or a non-container.

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 a '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.

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 a '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.

@@ -56,9 +63,14 @@

Whenever standard mathematical or Greek symbols are required, this text utilizes native Unicode characters rather than relying on escape sequences. For example, the text uses 'Î´' directly instead of, say, "\delta"; this might lead to some small typesetting variations.

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.

+ + + - The search that led to the Turing Machine + + The search that led to the Turing Machine

In 1893 Gottlob Frege published an axiomatic construction of mathematics from set theory. Frege's grand objective was something he called Logicism, the philosophical thesis that all of mathematics can be derived entirely from pure logic. To bridge set theory and logic, Frege defined sets using a method known as set comprehension. Under this approach, a mathematician states a logical rule or property, and any object satisfying that logical statement automatically becomes a member of the set. Because the membership of a set is determined entirely by logical rules, the resulting sets, and the mathematics built upon them, are derived directly from logic. To implement this, his specific machinery relied upon unrestricted set comprehension, formalized as Basic Law V Gottlob Frege, Grundgesetze der Arithmetik, Vol. 2 (Jena: Hermann Pohle, 1903), Appendix (Nachwort), 253.. @@ -135,8 +147,11 @@ The academic community was thus equipped with three mathematically equivalent foundations for computation theory: recursive functions, the lambda calculus, and the Turing Machine. While all three frameworks remain active subjects of study, Turing's model is unique in providing practical intuition through the abstraction of physical machines and programs. This made it the foundation of choice for computation theory textbooks by Stephen Kleene Stephen C. Kleene, Introduction to Metamathematics (Amsterdam: North Holland, 1952)., Martin Davis Martin Davis, Computability and Unsolvability (New York: McGraw Hill, 1958)., and Marvin Minsky Marvin L. Minsky, Computation: Finite and Infinite Machines (Englewood Cliffs: Prentice Hall, 1967)., leading to the modern standard presentations by authors such as John Hopcroft and Jeffrey Ullman John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison Wesley, 1979)., as well as Harry Lewis and Christos Papadimitriou Harry R. Lewis and Christos H. Papadimitriou, Elements of the Theory of Computation (Englewood Cliffs: Prentice Hall, 1981)..

+ + - The Turing Machine transforms mathematics into computing + + The Turing Machine transforms mathematics into computing

To apply his proof to the Entscheidungsproblem, Turing carried the additional burden of establishing that Hilbert and Ackermann's intuitive concept of an effective procedure was functionally equivalent to a Turing Machine program. Turing addressed this issue directly in his 1936 paper. Over the following decades, the academic community evaluated and accepted his argument, cementing what is now known as the Church Turing Thesis. This consensus supplied the necessary bridge between mathematics and modern computer science by formally equating the vague, historical notion of a human procedure with the rigorous, mechanical definition of an algorithm. @@ -173,10 +188,14 @@

+ + - The computer design abstraction stack + + The computer design abstraction stack -

The six levels

+ + The six levels

These are the discernible levels of the computer design abstraction stack: @@ -220,7 +239,10 @@ If a computer manufacturer keeps the architecture as a constant, all other levels can change, and a customer will be able to run the same software. The same organization can be used with different implementations. Minor changes in manufacturing process can sometimes be used with an older implementation, for example a simple transistor shrink.

The levels are not independent

+ + + + The levels are not independent

The layers are merely idealizations. In both practice and theory it is not possible to completely disentangle them. On a new machine of the same architecture, it is common that some software will require updates to run, and almost certainly specific operating system support will be required. @@ -242,14 +264,21 @@ This cascades down the stack, as organization instructs implementation, etc. For example, if the architecture has an instruction that names one of N registers as an operand, then the organization has a register file that data flows to and from, and busses to carry that data, the design will specify a register file and layout the busses, and the manufacturing people will build them.

Where the Turing Machine fits in

+ + + + Where the Turing Machine fits in

The Turing Machine is a computation theory object that is suggestive of a simple architecture, and a computer organization. A person who has had to do homework problems centered on Turing Machines will have tracked the flow of data through the machine, i.e. worked at the register transfer level. However, a little work is needed to complete the architecture analog. The fundamentals are present, the read/write head, the tape, the procedure for using the tape, but other components are missing. The manipulation of symbols remains ungrounded. The tape is not well defined. The use of emptiness is non architectural like. The tape transport is not articulated, though it is implied. The read buffer that is required, so the programmed controller can do a write without clobbering the read data needed for the next transition, is not identified as a component. As we proceed, we will likely discover other missing components.

+ + + - Computation theoretic consequentiality + + 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. @@ -259,7 +288,8 @@ 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.

Definition of the same results transform property

+ + 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: @@ -317,7 +347,10 @@ then we can say without qualification that T is a same results transform. Though still implied are the sets of machines, tapes, and questions.

Definition of the computation theoretic consequential/inconsequential transform property

+ + + + 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. @@ -367,8 +400,12 @@ then we can say without qualification that T is computation theoretic inconsequential. Though still implied are the sets of machines and tapes.

+ + + - The conventional Turing Machine + + 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)..

@@ -415,11 +452,12 @@

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

The reverse machine example

+ + The reverse machine example

Here is the programmed controller for a Turing Machine that reverses a binary string. Although by definition each state transition matches exactly one value under the head, as a practical matter, disjunctive selection is allowed via a comma list. A conjunctive phrasing for a state transition proposition would require stringing intermediate states in series.

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

@@ -537,7 +575,10 @@ done â¢ 0 1 1 -

Analysis of the reverse machine

+ + + + Analysis of the reverse machine

The total number of steps for reversing an n symbol string:

@@ -569,7 +610,10 @@

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.

Blank, empty, SP

+ + + + Blank, empty, SP

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

@@ -633,12 +677,17 @@

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.

+ + + - The computation theoretic TTCA Machine + + The computation theoretic TTCA Machine

This chapter presents a modified computation theoretic Turing Machine with three structural additions. First, it separates control flow from data flow, ensuring that payload symbols do not needlessly expand the control state machine. Second, it unifies the control and data symbol sets into a single alphabet to natively support explicit communications protocols even in the presence of recursion and self-recursion. Finally, it implements a cascading next-state evaluation hierarchy, permitting the programmer to formally define and handle meta-symbols while also making it more convenient to program communication protocols.

The unspecified meta-symbol

+ + The unspecified meta-symbol

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.

@@ -663,7 +712,10 @@

Recall the suggestion earlier in this section that "perhaps an algorithm could be studied for this very quality of not ever making decisions based on unspecified data." In this capacity, the unspecified symbol functions as a test probe. Such an analysis can be done with a two-layer architecture: a first-order machine under study and a second-order machine performing the analysis. The unspecified symbol resides within the alphabet of the second-order machine, which possesses the authority not only to move the symbol but also to base logic upon it. However, demoting the unspecified marker from a meta-symbol to a standard decision symbol leaves the second-order machine without a meta-symbol of its own. In a strictly layered architecture, analogous to Russell and Whitehead's hierarchy of types, a programmer could define unspecified-0, unspecified-1, and so forth, explicitly embedding the order as a unique identifier. However, if the system lacks this strict stratification, the layering strategy collapses. This occurs when a statement operates as an independent island of meaning, analogous to GÃ¶del's unprovable truths, or when an analyzer is tasked with evaluating itself, as in Turing's halting proof. Therefore, whether an unspecified meta-symbol can be deployed successfully depends entirely upon the structural boundaries of the specific system under test.

The modifications

+ + + + The modifications

The specific architectural modifications are as follows:

There is a mechanical procedure for converting a Moore Machine into a Mealy Machine, and the reverse. Two such converted machines are equally expressive. Making the read operation an explicit instruction, instead of having it implied by a state transition, increases the number of states in a controller, and consequently the number of steps that must be taken. However, the new machine can do in two steps anything the former machine could do in one; consequently, this change scales the step count formula by a constant factor, leaving the order of the highest term unchanged. The layers of next-state functions can be collapsed into one layer, where the missing arguments are filled in with all possible unused values. This potentially increases the number of state transition arcs that must be specified, but the state transition logic and the number of states remain unchanged. Partitioning the machine definition by separation of concerns does not change the total specification. Hence, these modifications are computation theoretic inconsequential.

The TTCA Machine fixed part

+ The TTCA Machine fixed part \mathit{MF} = (\mathit{QF}, \mathit{Î£F}, \mathit{AF}) @@ -745,7 +800,10 @@ \mathit{Î£F} = \{\mathit{Î£F}{Â·}\mathtt{leftmost}\} -

Machine variables

+ Machine variables \mathit{MV} = (q, s, d) @@ -758,7 +816,10 @@

d: is the data register value.

Programmable part

+ Programmable part \mathit{MP} = (\mathit{QP}, \mathit{Î£P}, \mathit{ÎP}, Î_0, Î_1, Î_2, Î_3, \mathit{HP}) @@ -825,7 +886,10 @@ -

The TTCA Machine definition in total

+ The TTCA Machine definition in total M = (q, s, d, Q, Î£, A, Î, Î, H) @@ -871,7 +935,10 @@ -

Computation theoretic TTCA Machine executor

+ Computation theoretic TTCA Machine executor

Computer was at one time a job title. Turing described a clerk following directions to cause his machine to go, thus implying that mathematicians are mere automata chained to following the procedures they derive. So then an executor can be a person, perhaps a student who is studying the computation theoretic machine, and has a homework assignment of showing what it does.

@@ -879,7 +946,8 @@

This description assumes support is programmed in for the first order unspecified symbol.

Initialization stage

+ + Initialization stage

Before the first cycle begins, a tape is selected and mounted. The read/write head is positioned over the leftmost tape cell. The machine variables are initialized as follows:

The current state q is set to \mathit{QF}{Â·}\mathtt{initial}.
The status register s is initialized to hold the \mathit{Î£F}{Â·}\mathtt{unspecified} symbol.

Programmed control stage

+ + + + Programmed control stage -

Phase 1: Instruction issue and execution

+ + Phase 1: Instruction issue and execution

Given the current state q, lookup the instruction Î», within the instruction table Î.
Perform the instruction Î».

If the instruction is left and the machine walks off the tape, the machine hangs.

Phase 2: The state transition

+ + + + Phase 2: The state transition

Following the completion of the instruction, the programmed controller evaluates the next state by cascading through the ordered sequence of transition rules Î = [Î_0 \mid Î_1 \mid Î_2 \mid Î_3]. The evaluation follows this hierarchy, stopping and branching at the first valid match. Upon not finding a next state transition, the machine hangs.

Halting stage

+ + + + + Halting stage

If, after the state transition phase completes, the current state is a member of H, the machine halts. Otherwise, the execution continues from the programmed control stage.

The TTCA Machine string reverse

+ +

+ The TTCA Machine string reverse

Because the TTCA Machine separates the data path from the control path, it is possible to reverse a string without inspecting the payload. The programmed controller only needs to recognize the structural boundaries of the data protocol. When a payload symbol is encountered, the controller executes a read(d) instruction, placing the value into the data register, which is not examined for decision-making purposes. When a value is used to base a decision upon, the controller executes a read(s), placing the value into the status register. Because instructions are bound to states rather than transitions, reading and stepping are distinct states. This combination of features results in a controller that has threads of serialized execution.

@@ -1048,9 +1131,12 @@ QÂ·Done - TTCAM reverse machine

Analysis of the TTCA reverse machine

+ Analysis of the TTCA reverse machine

The number of states is constant at 24 independent of how much data is to be reversed. No arc refers to a payload value.

@@ -1121,7 +1207,10 @@ -

Two-headed reverse string example

+ Two-headed reverse string example

The reverse string machine spends a lot of time shuttling the head between two context areas: one for the original string, and one for the resulting reversed string. This suggests that a two-head version would be faster. The following is the two-head state machine definition:

@@ -1226,9 +1315,12 @@ QÂ·Done - TTCAM 2 hd reverse machine

+ +

Analysis of the two-headed reverse string machine

+ Analysis of the two-headed reverse string machine

The number of states has dropped from 24 to 18, while the speed increase is dramatic, with the former quadratic performance becoming linear performance. The total number of steps for reversing an n symbol string using a two-head TTCA architecture:

@@ -1291,10 +1383,14 @@

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.

The TTCA Machine design

+ The TTCA Machine design - Figure 1: A Turing Machine

The prior chapter on the computation theoretic TTCA machine serves as the architectural template, with only a few modifications. The architecture requires explicit data rather than accepting meta-symbols like 'unspecified' as presumed initial values 'by definition'. Actual values are transacted. Now that data and control have been separated, the controller is practical to implement, and even more so because it was defined in terms of tables that can be built in hardware. As the read status instruction returns the cell type, it will in its current form be able to return 'rightmost', so the right end of the tape can be detected. In order to extend the tape, the machine will stop and ask the operator to mount a new reel. This could be signaled when the user attempts to step right of rightmost, either by a panel light that illuminates upon the machine finding a rightmost status, or by the program printing a message on the console teletype. As this is a constant-time operation, it is computation theoretic inconsequential.

@@ -1313,7 +1409,8 @@

Suppose a controller is not analyzed to determine its computation theoretic complexity, or even tested against worst-case inputs, but is instead run with random or everyday input to gather performance measurements. This process is called profiling. After many runs, a programmer might surmise the behavioral limits of the program. However, many programs are neither linear systems nor smooth functions. With a different set of inputs than those used for profiling, perhaps even values adjacent to prior inputs, the program behavior can shift drastically. Consider the Pentium divider. It did not matter how many millions of times the result was accurate; the fact remains that customers later found inputs that yielded wildly inaccurate results. Only by elevating the analysis to the structural logic of the code can such an eventuality from an erroneous program be categorically ruled out. This is why the K5 transcendental function development project included a proof writing phase; see 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.

Head Unit, HU

+ + Head Unit, HU

An HU contains a head and a local controller. The local controller supports these instructions:

@@ -1338,7 +1435,10 @@

Because values can only be read or written to a tape when the tape is in motion, it is advantageous to exaggerate the motion of step instructions and to cache a small number of values. In addition, most architectures that make use of a tape drive will attempt to leverage high throughput in an effort to hide high latency by reading or writing blocks of symbols per tape access. Note, however, that the basic TTCA Machine organization lacks the core memory required for buffering blocks.

Tape transport unit, TTU

+ + + + Tape transport unit, TTU

The TTU is the component where tapes are mounted and unmounted, and where read/write head units are installed. When multiple HUs are plugged in, the controller passes control among them so it appears that heads never collide. The TTU controller has these components:

@@ -1362,11 +1462,14 @@

The head argument multiplexes the instruction to the specified head. If the TTU has one head, the head argument is optional. The last two instructions cause the tape to be moved such that, relatively, the selected head moves left or right by one cell.

The customer programmed control unit, CPCU

+ + + + The customer programmed control unit, CPCU

The controller is programmed via patch panels. The panels would look something like what is shown in the following ASCII art blocks. Note that â indicates an illuminated indicator light, whereas â is not illuminated. [/] represents an open toggle switch, while [â] is a closed one. {*} is a pushed button, while { } is a button that is not pushed. ( ) represents a hole for a banana plug. Each patch cord has a banana plug on each end. Plugging a patch cord between separate panels will void the warranty ;-).

+      
                           [ CONTROL PANEL ]
                 +-----------------------------------+
                 | POWER [â] â  ERROR â    RESET { } |
@@ -1374,9 +1477,9 @@
                 +-----------------------------------+
                 | RUN/STEP [/]  â  STEP { }         |
                 +-----------------------------------+
-

+ -

+      
                                  [ State Transition Table ]
                          +-------------------------------------------+
            current state |  def   q0    q1    q2    q3    q4    q5   |
@@ -1392,9 +1495,9 @@
                          |                                           |
        destination state |        ( )   ( )   ( )   ( )   ( )   ( )  |
                          +-------------------------------------------+
-

+ -

+      
                                [ Instruction ]
                     +-----------------------------------+
                     | q0    q1    q2    q3    q4    q5  |
@@ -1408,9 +1511,9 @@
           write('d')| ( )   ( )   ( )   ( )   ( )   ( ) |
           write('Ï')| ( )   ( )   ( )   ( )   ( )   ( ) |
                     +-----------------------------------+
-

+ -

+      
                         [ Sigma Select for write('Ï') ]
                     +-----------------------------------+
                     | q0    q1    q2    q3    q4    q5  |
@@ -1422,7 +1525,7 @@
                 s3  | ( )   ( )   ( )   ( )   ( )   ( ) |
                 s4  | ( )   ( )   ( )   ( )   ( )   ( ) |
                     +-----------------------------------+
-

The top panel has two toggle switches. One turns the machine on, and the other selects run or single-step mode. Immediately to the right of the two toggles are indicator lights. To the right of the indicator lights are two push buttons. One is for reset, which sends the machine back to state q_0, and the other is for stepping the machine when it is in single-step mode. This panel also has an error indicator light which will illuminate if no next state is specified for a state transition, and thus the machine is hung, or if a head walks off the end of a tape.

@@ -1436,10 +1539,13 @@

Below the transition panel are the instruction selection and symbol selection panels. To enforce the rule that each state executes exactly one instruction, each state column on the instruction panel features a single source hole at the top. The programmer routes a patch cord from this source hole down to the desired instruction row. If the selected instruction requires a symbol argument, such as write('Ï' ,Ï), a similar routing is performed on the bottom symbol selection panel. Note that this describes the control panel for a single-head, single-TTU machine. Additional patch options would be required to add a TTU device specifier and a head specifier within each TTU.

The machine block diagram

+ + + + The machine block diagram

@@ -1503,7 +1609,8 @@ The tape transport unit, TTU, handles mounting, unmounting, reading, writing, and moving the tape. In this volume, we treat head motion in a relative sense, recognizing that a physical TTU moves the magnetic tape beneath a stationary head rather than displacing the head across the tape. Our architecture allows a system to incorporate multiple TTU modules, each containing its own read buffer, status buffer, and head assembly. Tapes can be dynamically mounted, unmounted, shelved, and transferred between any TTU on the same machine or across distinct systems.

Description of a read('s') instruction

+ + Description of a read('s') instruction

The current state register, q, samples and holds on the rising edge of the clock. This then provides a stable state signal to the control panel next state matrix columns for an entire cycle. The status register, s, is the phase inverse; when enabled it samples on the falling edge of the clock and holds for an entire cycle.

@@ -1521,8 +1628,13 @@ + + +

Area and partitioning

+ Area and partitioning

We call a subset of contiguous cells from a tape an area. An area with a single cell is called a singleton, one with two cells is called a pair. An area has a leftmost cell and a rightmost cell. For a singleton area, those will be the same cell. @@ -1534,7 +1646,8 @@

A tape partition is a set of areas that completely span a tape. For any partition of a single ended Turing Machine tape, at least one of the areas will necessarily be infinite.

Head partition

+ + Head partition

The left side: The finite set containing all of the cells to the left of the head cell.

If the head is on the leftmost cell, there is no left side area.

Leftmost/remaining partition

+ Leftmost/remaining partition

Leftmost: the leftmost cell.
Remaining: the infinite set including the right neighbor of the leftmost cell, and all cells further to the right.

Active area partition

+ Active area partition

A nonempty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: @@ -1569,13 +1688,19 @@ A noncomputational tape is one that cannot be initialized by a Turing Machine, but can still be surmised to exist, perhaps in analysis due to its properties. The empty tape is an example. The tape holding the Natural Numbers is another example. For noncomputational tapes that have the property that the active area is open on the right, there is no right empty tail.

Area implied partition

+ Area implied partition

The existence of a finite given area implies a three area partition: the left side, the given area, and the right side. If the given area is located at the left end of the tape, there is no left side area. If the given area is open on the right, there is no right side area.

The impossibility of recognizing an empty tape

+ The impossibility of recognizing an empty tape

Recognition is a process where a Turing Machine decides if a pattern is present on a tape solely by reading symbols found on the tape. No meta information, such as a message communicating something about the area being examined or the nature of the program that wrote the symbols, can be taken into account. @@ -1589,7 +1714,10 @@ Recognizing that a tape is empty is generally impossible. Suppose it were attempted, and a machine started scanning the tape rightward from the leftmost cell; for every cell that is discovered to be empty, the machine would have to scan further rightward to check for an alphabet cell. If the tape is truly empty, the recognizer would never stop scanning, so no decision would ever be rendered.

The impossibility of recognizing the rightmost cell of the active area

+ The impossibility of recognizing the rightmost cell of the active area

In general, a Turing Machine cannot step across a tape reading cells to recognize the rightmost cell of the active area, or equivalently, the leftmost cell of the right empty tail. Suppose a recognizer attempted this by starting in the active area and stepping right, and the machine discovered an empty cell. The machine would be unable to distinguish between the case of said empty cell being embedded within the active area (meaning more alphabet cells lie further to the right), or the case where said cell is genuinely the leftmost cell of the right tail. To resolve the ambiguity, the machine would be obligated to continue stepping right. Yet, there would never come a time where finding another empty cell would avoid leading back to the exact same case ambiguity, so the machine would forever step right without returning a decision. @@ -1611,7 +1739,10 @@ When an input tape is provided as a general mathematical object, either decreed by definition or perhaps abstracted from 'what a Turing Machine computation would produce in the limit of step count', then the input can be either finite or infinite.

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. @@ -1625,7 +1756,10 @@ In contrast, out-of-band control communicates structural information through a strictly separate channel or by utilizing symbols definitively excluded from the programmer visible data alphabet. The rightmost tape marker is an out-of-band mechanism because it utilizes an expanded hardware tape alphabet strictly reserved for machine management, guaranteeing it can never be conflated with the user's data. Modern architectures often lack the luxury of inventing new symbols to serve as control rather than data. Another out-of-band signaling technique is to structure the data into channels; such structure is called formatting. We find formatting on hard drives, in frame based and packet based communication channels, and in data structures.

Virtual cells

+ Virtual cells

A given finite area that is not sitting on the end of the tape will have a left neighbor area and right neighbor area that are not in the area. If the given area is sitting on the end of the tape there will be no left neighbor area. If the area is open on the right, there will be no right neighbor area.

@@ -1634,7 +1768,10 @@

An example of this from conventional computing is where memory is accessed in units of bytes, but a program works with units of words.

Virtual tape

+ Virtual tape

As established, the Turing Machine head transport returns a distinct left-of-leftmost symbol when stepping left off the end of the tape. The programmed controller, the statement machine, then uses an arc defined specifically for this symbol. It is a distinct symbol that cannot be written to the tape.

@@ -1659,7 +1796,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Suppose further that this area is finite. If the machine attempts to step right from the rightmost cell of this finite area, the tape transport returns, in analogy, right-from-rightmost symbol. Such a machine defines a virtual tape over an area.

Partitions on a finite virtual tape

+ Partitions on a finite virtual tape

When a Turing Machine operates on a finite virtual tape, the structural logic of the partitions established earlier must be updated to reflect the absolute rightward boundary. @@ -1671,10 +1811,15 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

For the Active area partition, the right empty tail is similarly a finite set extending to the rightmost boundary of the virtual tape. If the rightmost alphabet cell occupies the rightmost cell of the virtual tape, the right empty tail does not exist.

+ +

Metrics

+ Metrics -

Address defined area

+ + Address defined area

We defined a tape as having a single feature, that of a leftmost cell, along with a linear neighbor topology. When a tape is mounted it gains a second feature, that of the cell the head is on. The leftmost cell was fixed in place, while any other single cell on the tape can be featured as the cell the head is on. When we introduced areas, we picked up two new features, that of the leftmost cell of the area, and the rightmost cell of the area. Again, those features could coincide with the former features. We noted that the features partitioned a tape thus defining more areas, and more features.

@@ -1697,7 +1842,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

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.

Distance and extent

+ + + + Distance and extent

The distance between two cells is the absolute difference in their addresses. When we talk about the distance between the leftmost cell of an area and the rightmost cell of an area, we call this number the area's extent.

@@ -1707,7 +1855,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

It is interesting that the extent of an area will be the same, whether it is calculated from the address space of the tape, or the address space of the area. In fact, the extent will always be identical to the largest address in the address space. We will use the Greek symbol omega, \omega, to symbolize an extent. We can give it a subscript with the name of an area if the correspondence is not already clear. The choice of \omega makes sense here because \omega is an inclusive bound, i.e. it is the rightmost letter included in the Greek alphabet. Thus it is the extent of the Greek alphabet.

Length

+ + + + Length

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.

@@ -1715,11 +1866,15 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

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.

Is the cardinality of an open on the right area a Natural Number?

+ + + + Is the cardinality of an open on the right area a Natural Number?

So we find an interesting situation with the cardinality of an address space for an area that is open on the right. It goes like this.

How cardinality is computed

+ + How cardinality is computed

We set Turing Machine P with its head on the leftmost cell of an area. We mount the initial tape, 'Â·', on the A machine.
The A machine is run an additional time. The output on the tape is defined to be the cardinality of the address space, aka the cardinality.

Lemma 1, the A machine produces Natural Numbers

+ + + + Lemma 1, the A machine produces Natural Numbers

This follows from its definition; it is literally the increment from the Natural Numbers Machine.

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.

Lemma 3, cardinality is not in the address space

+ + + + Lemma 3, cardinality is not in the address space

At the end of the second step in the procedure for producing the cardinality, the tape of the A machine held the extent of the address space. Then in step 3, A was called again, thus leaving a number one larger than the extent on its tape. The extent is the largest number in the address space, hence cardinality is larger than all numbers in the address space. Thus cardinality is not in the address space.

Lemma 4, the address space of an open on the right area is identical to the Natural Numbers.

+ + + + Lemma 4, the address space of an open on the right area is identical to the Natural Numbers.

Composing the A machine with an unterminated loop call, where each result is written to a tape with a terminator between entries, results in the same machine as the Natural Numbers Machine.

The apparent contradiction.

+ + + + The apparent contradiction.

By Lemma 2, cardinality is a Natural Number. By Lemma 3 cardinality is not in the address space. By Lemma 4 the address space is identical to the Natural Numbers.

Resolution

+ + + + Resolution

The resolution lies in the computational reality of Step 2. For an area that is open on the right, the stepping of machine P never halts. Because Step 2 never terminates, Step 3 is never executed. The A machine never runs that final, additional time. Therefore, the cardinality of an open area is never actually produced by the machine. In the language of Computational Naturalism, Lemma 2 is false for an infinite area; the cardinality of an open on the right area is excluded from being a Natural Number because a Natural Number Machine cannot reach it in the first order.

@@ -1757,7 +1930,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Such a value would be a new Turing Machine, one that composes a call to the never halting Natural Number machine followed by an increment operation. It cannot be run, but it perfectly explains the situation to an analyst. Perhaps we name this machine \aleph_0.

What if extent was used instead of cardinality?

+ + + + What if extent was used instead of cardinality?

Had extent been used instead of cardinality, we would lack the final increment step in the three step computing procedure. However, step 2 still cannot complete. Rather than a value, the result of the second order analysis would be a machine that produces ever larger Natural Numbers. We can call this machine \aleph_{-1}. @@ -1776,14 +1952,23 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Size

+ + + + + 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.

- Natural Number + +

+ Natural Number -

Unary representation

+ + Unary representation

A person can define a Turing Machine that is identical to the recursive definition of Natural Numbers as given by Peano. Giuseppe Peano, Arithmetices principia, nova methodo exposita (Turin: Fratres Bocca, 1889). If a person were to run the Natural Number Machine and observe as it writes to the tape, that person would watch as the Natural Numbers are printed one after another: 'Â·sÂ·ssÂ·sssÂ·ssssÂ· ...'. Here 'Â·' represents zero, and 'sÂ·' represents one, etc. Because the Natural Number Machine never halts, the machine cannot be used to initialize a tape, but an analyzer can evaluate the machine to make conclusions about what it would write if it were run. @@ -1809,7 +1994,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos An address space is a set of addresses for contiguous cells. The tape's address space is the set of addresses for all the cells on the tape. Typically the address of 0 is given to the leftmost among the contiguous cells.

Hindu-Arabic representation

+ + + + Hindu-Arabic representation

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.

@@ -1922,12 +2110,18 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Consequently, maintaining an Hindu-Arabic address on a secondary Address Machine remains a constant time operation in the amortized sense, making it computationally inconsequential to the complexity class of the base machine. However, if a problem were to increment and decrement repeatedly around a binary power count, the behavior would be the limiting logarithmic time due to the length of the counter. An unlucky situation like this is called aliasing.

The Computability of Length and Unbounded Zeros

+ + + + The Computability of Length and Unbounded Zeros

Consider the proposition of representing Natural Numbers with an unbounded sequence of leftward-trailing zero symbols, extending from the leftmost nonzero digit. If a Turing Machine attempts to evaluate the length of this number, or append a digit to the left of its most significant digit, the machine encounters a structural failure. Any algorithm that starts at the right of the sequence (the least significant digit) and scans leftward in search of the last non-zero digit can never be sure at any step that there isn't another non-zero digit further to the left, as those members of the sequence have not yet been examined.

Thus, an append function can never know where to write the appended digit, and a length function can never know when to end the count. Because these functions cannot be computed locally on a tape initialized with unbounded zeros, the viable Arabic Representation must strictly be a finite, growing sequence rather than an unbounded string of zeros. If an algorithm attempts to access an index greater than the extent of this finite sequence, the access function fails. This failure is itself a form of meta-informationâinformation about the structure of the representation rather than the number it encodes.

The Representation of Zero and Structural Emptiness

+ + + + 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.

@@ -1940,7 +2134,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Without explicit brackets, the empty sequence collapses into an empty space, conveying no meaning when written in conventional notation. To maintain visual clarity and avoid empty spaces where zero should appear, conventional architectures adopt the standard 0. However, the length function must still return zero for [0], despite its apparent length of one.

Numeric value

+ + + + Numeric value

An Hindu-Arabic number consists of a sequence of digits, d_0 d_1 d_2 \ldots where, in base 10, each digit has a value ranging from 0 to 9. In this section, these sequences are represented using sequence notation. For example, X = [7, 8, 9] is a sequence with three components. Its zero index component, x_0, is 7, etc. Note that X is written as a capital letter to denote that it is a container, while its individual members use small letters.

@@ -1954,7 +2151,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Independent of whether the number is represented with or without the bracket decoration, its most significant digit is the one with the greatest weight. In this example, it is the digit with the value 9, i.e., x_2. Analogously, the least significant digit is 7, i.e., x_0. Using a term from the previous chapter on arrays, the extent of our example number is 2. The digit count, or length, of this number is 3.

Meaning of the word digital

+ + + + Meaning of the word digital

The information about ENIAC in this chapter is found in a 1947 IRE article, "Electronic Computing Circuits of the ENIAC" by Arthur W. Burks Arthur W. Burks, "Electronic Computing Circuits of the ENIAC," Proceedings of the IRE 35, no. 8 (August 1947): 756-767. DOI: 10.1109/JRPROC.1947.234265. I found it interesting that some of the design issues for flip-flops made of vacuum tubes resemble those of designing static RAM cells in CMOS. Although ENIAC's implementation is electronic, its architecture is fundamentally that of a mechanical machine.

@@ -1978,7 +2178,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Most computer users never see a memory dump. Instead, they see the output of print functions. By default, print functions render numbers in a decimal format familiar to the user, independent of the internal representation used for numbers. In contemporary computing, the time it takes to convert a binary number to a decimal number is negligible compared to the time required to execute a long computation, so decimal printing is practical.

Scanning-Order and Digit-Order

+ + + + Scanning-Order and Digit-Order

Had this book been written in Hindu-Arabic, the text would be written right to left. Let us explore what that looks like by using an example where we start with an English sentence and then reverse it. Notice that in this right to left string, the sequence [9, 8, 7] without notation is 987. Both strings match.

@@ -2010,7 +2213,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Because a page of text is two-dimensional, there are additional writing direction conventions. However, computer memory is one-dimensional, so only the two discussed here are relevant to this architectural discussion. Programmers tasked with writing display drivers encounter the others.

Binary, Octal, Hexadecimal, BCD

+ + + + Binary, Octal, Hexadecimal, BCD

A person interprets a sequence of n bits as a number by using this function:

@@ -2085,7 +2291,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Although BCD encoding is less efficient, BCD encoded binary place values numbers still grow in length logarithmically while counting. Because numbers are represented in base ten, no number conversion is necessary when printing, though today this performance cost is insignificant. More importantly, BCD numbers divide by ten without generating infinite fractions.

Allocation

+ + + + Allocation

In most text documents, a number is written down once and remains unchanged. In contrast, a computing program frequently returns to the exact memory location and changes its value. This is equivalent to erasing an old value on a paper document and writing a new value in the same space.

@@ -2108,14 +2317,14 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Figure 10 depicts a word featuring byte addresses represented in hexadecimal, running from c0 to c3. (In decimal these addresses represent 192, 193, 194, 195). The address of the byte before c0 is bf. The address after c3 is c4. The address for the word itself evaluates to c0, as it is the minimum byte address. This word holds a little-endian number. Treating a byte as an octet digit, the binary encoding for the least-significant digit of this number is 0001 1000. The most-significant digit is 1010 1110.

Figure 10: Left justified, least-significant-digit-first

In Figure 11, 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 the prior figure, it retains the identical least-significant digit and most-significant digit.

Figure 11: Same number using big-endian digit order

@@ -2127,7 +2336,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

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.

Bit Order Within Bytes

+ + + + Bit Order Within Bytes

Data transports between hardware nodes over bundles of wires called buses. Bus specifications explicitly define the order of bits in bytes, and for contemporary machines, bytes are strictly octets. All compute processors, channel processors, and attached devices must conform to the busâs specifications.

@@ -2139,7 +2351,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Because doing so is impossible in all but special cases, an address points at the entire byte, rather than pointing at the most significant bit or the least significant bit.

Byte Order Within Words

+ + + + Byte Order Within Words

A specific processor architecture features native support for byte data alongside varied word lengths, most commonly 16, 32, and 64 bits (or 4, 8, and 16 bytes).

@@ -2150,14 +2365,14 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

The following figure displays a stream of bytes arriving as data and being copied into a word. The digits of the word (the bytes) arrive in little-endian order and target a little-endian machine, so they are written in the exact order they are scanned off the channel.

Figure 12: In-address-order byte by byte copy

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.

Figure 13: Reverse order byte copy for words

@@ -2171,12 +2386,19 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Various file formats and data communications standards serve specific classes of applications by explicitly defining where words that require reversal are located during machine-to-machine data transfers.

TTCA

+ + + + 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.

+ +

Address

+ Address

@@ -2273,8 +2495,11 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos In computer architecture, there is a rule that the slower the access time, the larger the amount of data that should be transferred. The idea is then that of access time per bit, instead of access time per fetch. A common example given is that of a station wagon of hard drives driven across the country. Andrew S. Tanenbaum famously coined this concept in his 1981 textbook Computer Networks, stating: "Never underestimate the bandwidth of a station wagon full of tapes hurtling down the highway." This physical data transfer method is universally referred to as a sneakernet. Ten terabits, at three days, equates to 26 nanoseconds per bit. Not bad, if a user can wait three days to continue the program, but aliasing between data sets would make a program very slow. The Turing Machine model does not capture the effects of clumped data accesses.

The Universal Turing Machine

+ 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.

@@ -2397,10 +2622,14 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

This is an assembly-level code description of an instruction sequence. To get it into final form, the labels that appear as instruction arguments would be replaced with their addresses. Symbolic labels would not appear on the tape. As an alternative to using absolute branches, relative branches could be used. Performance will be greatly enhanced for a sequencer that performs relative branching if it contains an adder circuit; otherwise, the addition of offsets would be another TTCA program invocation.

The software layer

+ The software layer -

Symbol in mathematics

+ + Symbol in mathematics

A symbol is a distinct mathematical object capable of being instantiated. Within a given context, any instance of a specific symbol evaluates as equal to any other instance of that identical symbol, and evaluates as not equal to any instance of a different symbol. @@ -2414,7 +2643,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos It follows from this definition that the distinct equivalence classes can be used as a proxy for the instantiable objects themselves. That is, a person can name either the instantiable object or the equivalence class, and then through this correspondence, find the other.

Symbol in computing

+ + + + 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. @@ -2424,7 +2656,8 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos A symbol instance newly minted by the factory is said to come direct from the factory. A symbol instance direct from the factory is also called an original.

Required properties of symbol factories

+ + Required properties of symbol factories

Any two symbol instances returned directly from two distinct factories will always evaluate to False during an equality comparison. In other words, two distinct originals will always be not equal. @@ -2442,7 +2675,10 @@ 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.

Instance implementation

+ + + + Instance implementation

Within a process, a reference to the factory can be used as a symbol instance, which will cause the factory to become trivial. Making a new instance will merely require copying the factory reference, and there will be nothing in memory that the base factory reference is pointing to. @@ -2468,7 +2704,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos At the time of this writing many machines use 64 bit words. This is equivalent to 8 ASCII characters, while the average size of an identifier is about 5 characters. Hence the approach of using a string as a symbol might not be as inefficient as it seems to be at first. Using strings has advantages. Symbol instances can carry semantic clues for the programmer. There is no hazard of conflating the string instance with the name, as they are the same. Also, a string instance will have integrity across contexts, such as between invocations or when passed between processes (note the section below on crossing context boundaries). A drawback is in cases there is no language support, the strings are typically ad hoc so the guarantee of distinctness becomes merely a contract with the programmer.

Distinctness across contexts

+ + + + Distinctness across contexts

If a symbol persists across contexts (such as across scopes or processes), it must remain distinct from all other symbols in its new context. @@ -2482,7 +2721,11 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos When utilizing memory addresses as symbols in a virtual memory environment, the convention is to disallow addresses in one process from being used in another. If that isolation is insufficient, it is often adequate to use indexes instead of addresses, taking the address to the base of the data structure. Though the absolute address of the data structure might differ across contexts, the relative offset remains constant. Another approach is to reserve memory address blocks and to guarantee imported pages have the exact same addresses as before, though they might be imported sequentially to reuse the memory block. In architecture, this is generally known as the pointer swizzling problem.

Symbol copy consequentiality

+ + + + + 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. @@ -2500,7 +2743,10 @@ 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.

Alphabet

+ + + + Alphabet

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.

@@ -2508,7 +2754,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

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.

Symbol implementation examples

+ + + + 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. @@ -2604,13 +2853,19 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos } -

Property

+ + + + Property

A property is a pair, where the components are called the name and the value. A name is an instance of a symbol and it must uniquely identify the property within its context. The value is a variable that can be written then read back.

Dictionary and reference

+ + + + 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.

@@ -2618,7 +2873,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

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

A Turing Machine tape cell

+ + + + A Turing Machine tape cell

A cell is the square from Alan Turing's 1936 paper Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265.. Mathematically, a cell is a referencable distinct identifiable set, with one to three property members depending on the type of cell. @@ -2632,7 +2890,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos The value of a neighbor property is a non-null single reference to a cell. The value of a data property is strictly an instance of an alphabet symbol, or alternatively, an instance of the empty symbol.

Tape

+ + + + Tape

A tape is a set containing exactly one leftmost cell and an infinite number of medial cells. For each cell in the set, called cell A, if cell A has a right neighbor that is cell B, then cell B's left neighbor is cell A. Similarly, if cell A has a left neighbor of cell B, then cell B's right neighbor is cell A. Furthermore, any cell in the set must be reachable by traversing right neighbors starting from the leftmost cell, in a finite number of steps. @@ -2661,10 +2922,15 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos + + + - Computational Analysis + + Computational Analysis -

Definition

+ + Definition

In mathematics, analysis is the rigorous study of limits, continuity, rates of change, and bounds. It encompasses several specialized branches. Real analysis studies the behavior of real numbers, sequences, and continuous functions. Complex analysis extends these principles to functions of complex variables. Functional analysis examines vector spaces where the elements themselves are functions. Numerical analysis focuses on the design of algorithms to yield approximate solutions for continuous mathematical problems. Harmonic analysis studies the representation of functions or signals as the superposition of basic waves, such as Fourier series. Across all these branches, analysis provides a formal framework for evaluating mathematical objects. @@ -2708,7 +2974,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

Second order Arithmetic

+ + + + 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. @@ -2874,7 +3143,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

This technique of composing Turing Machine programs in the presence of simplification is closely related to that of symbol computation and expression simplification that we find in math tools such as Mathematica. We can imagine our Turing Machines as functions with names, and then symbolic computation leaves them unevaluated as here. Then the Mathematica Simplify is the compiler optimization simplifier as above. A difference in these two systems is that of the functions being reduced to Turing Machine head and tape transport unit instructions.

The multiplicative inverse of the additive identity

+ + + + The multiplicative inverse of the additive identity

Generally it is more efficient to perform arithmetic in the first order. Also, it is easier to write Turing Machine control programs if we take Natural Number arithmetic as already available, say, from a subroutine library. On processors fixed word length arithmetic is built into the hardware. Where second order computation becomes useful is in places where a result cannot be computed in the first order. @@ -2912,7 +3184,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos The divide machine cannot be run to produce a value, as any value from the field assigned to it would lead to contradictions. Stated more precisely, for x Â· y = q operations, when given an x and a q value, there is only one possible y value, and it can be recovered with q/x. However, when x is zero, and only when it is zero, q is solely determined by x independent of y, so y is ignored; it could be any value. There is no way to recover it from q/x.

Evaluating and Extending

+ + + + Evaluating and Extending

When a machine is 1) programmed to perform a function f, 2) has its tape initialized with a constant input value, say t (which can be a vector of values), and 3) is then run, writing the result f(t) and halting; we say that the run evaluates the function at t. @@ -3013,7 +3288,8 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos For Call 2, the input tape is the result tape from Call 1. Execution then proceeds identically to Call 1. This pattern repeats for all successive calls. A person can see the values of t^2 as the first number on each result tape. Any polynomial can be computed in this manner, and the only ALU required is an adder that is also capable of subtraction.

Lemma: Only row 0 is needed

+ + Lemma: Only row 0 is needed

The extension function can be called any number of times when the initial tape is identical to row 0 of the table of finite differences. No other row is needed from the table of finite differences. @@ -3023,7 +3299,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos This follows from the mechanical procedure given above for computing the next row of the table from any given row.

Lemma: Evaluating call \omega requires an initial tape populated with components 0 through \omega of row 0

+ + + + Lemma: Evaluating call \omega requires an initial tape populated with components 0 through \omega of row 0

Let the extent refer to the maximum index for accessing a component of a vector; the extent is often denoted as \omega. Performing extensions to calculate the function value at call \omega makes use of the initial tape up to index \omega, or as many nonzero values as are available up to that extent. @@ -3071,7 +3350,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos As a consequence of this lemma, we know that for any finite number of calls, i.e. finite \omega, that a finite prefix of D_0 is used.

Lemma: A polynomial function of degree \omega will have a D_0 vector of extent \omega

+ + + + Lemma: A polynomial function of degree \omega will have a D_0 vector of extent \omega

A polynomial of degree \omega is defined by a highest order term a_\omega t^\omega. The first forward difference operator, Î´ f(t) = f(t+1) - f(t), inherently cancels the t^\omega term. The binomial expansion of (t+1)^\omega yields t^\omega as its leading term, which subtracts out, leaving a new polynomial of exactly degree \omega - 1. @@ -3081,7 +3363,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Taking successive finite differences reduces the degree of the polynomial by exactly one at each step. Consequently, the \omegath difference evaluates to a constant, and the next difference evaluates to exactly zero.

Lemma: A D_0 vector of finite extent \omega generates a polynomial function of degree \omega

+ + + + Lemma: A D_0 vector of finite extent \omega generates a polynomial function of degree \omega

If an initial difference vector D_0 has an extent of \omega, the sequence of function values generated by the machine corresponds to a polynomial of exactly degree \omega. A person can demonstrate this by algebraically recovering the polynomial constants, a_i, directly from the initial tape components, D_{0, i}. @@ -3194,7 +3479,11 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Because the nth binomial coefficient expands into a polynomial of exactly degree n, and the summation is bounded by the finite extent \omega where D_{0, \omega} is definitively nonzero, the constructed function f(t) is structurally guaranteed to be a polynomial of degree \omega.

Difference table for an exponential function

+ + + + + Difference table for an exponential function

Here is the table of finite differences for the function 2^t. @@ -3257,7 +3546,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Instead of attempting to write an infinite sequence to a physical tape, a person can encapsulate the generation logic within a dedicated Turing Machine. In the tradition of constructive arithmetic associated with Boehm, this generator machine acts as a virtual tape. When the primary extension machine requires the next difference component, it queries the generator machine, which computes and yields the value on demand. This lazy evaluation strategy elegantly handles functions with infinite difference sequences without exhausting finite memory.

Composition of recurrence functions

+ + + + Composition of recurrence functions

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

@@ -3267,7 +3559,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

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).

A pole and zero cancellation

+ + + + A pole and zero cancellation

Here we circle back to the division by zero problem, though this time while extending functions. Let us begin with the two functions, f(t) = 2^t - 32 and g(u) = u - 15. Both have D_0 vectors, though the one for the exponential function is defined by a machine rather than by a value on a tape. @@ -3285,7 +3580,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos h(t) = \frac{f(t)}{g(t)} = \frac{2^t - 32}{3t - 15} - Figure singularity plot +

@@ -3387,7 +3682,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos So then, perhaps we set the value at the singularity to x build out the difference table, then solve for x?

@@ -3416,9 +3711,9 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

The resulting D_0 vector for the quotient is:

I find it fascinating to watch the transcendental difference values march down the table, then all cancel out after h(5) is generated. @@ -3493,7 +3788,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos -

Chapter discussion

+ + + + Chapter discussion

The fundamental claim of computational analysis is that all functions can be viewed as discrete entities. Take this simple function:

@@ -3526,10 +3824,15 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos + + + - Appendix: The Tension Between Formal Methods and Practical Architecture + + Appendix: The Tension Between Formal Methods and Practical Architecture -

Does computation theory matter to computing?

+ + 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. The following table provides the historical date that the variable value would finally be loaded into the processor, depending on the memory tier being accessed: @@ -3584,7 +3887,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos -

Do formal methods belong in computer design?

+ + + + Do formal methods belong in computer design?

The latency table above speaks to the physical reality that constrains all programs, entirely independent of their theoretical complexity class. This illustrates why computer architects spend almost their entire effort designing machines that execute as many instructions per cycle as possible, operating within a memory subsystem mathematically optimized to keep data in the lowest latency tiers. As a demonstration of this industry focus, there is not a single chapter dedicated to computation theory in Hennessy and Patterson's definitive textbook on the subject John L. Hennessy and David A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed. (Cambridge: Morgan Kaufmann, 2017).. @@ -3647,8 +3953,12 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos This continuous tension between pure formal models and practical execution speed remains a defining characteristic of the field, driving the structural logic behind modern mechanisms dealing with instruction pipelines, branch prediction, and memory aliasing.

+ + + - Or, does it go the other way? Computational Naturalism + + Or, does it go the other way? Computational Naturalism

Given that we have an architectural definition for a Turing Machine, and will modify this in a later chapter to define a realizable Turing Complete architecture, it is possible to invert the foundation of mathematics. Instead of mathematics preceding computation, we posit that given a Turing Machine exists, all of mathematics is an interpretation of what can be done with it. @@ -3703,8 +4013,11 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

+ + - Appendix: Stirling Numbers + + Appendix: Stirling Numbers

James Stirling introduced these numbers in his 1730 publication, Methodus Differentialis, a text that directly expanded upon the foundational work laid by Newton. @@ -3718,7 +4031,8 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos To understand their mechanical role, a person must look at the mathematical basis used in each domain.

The Continuous vs. Discrete Basis

+ + The Continuous vs. Discrete Basis

In continuous calculus, the natural basis for polynomials is standard exponentiation, t^n. The continuous derivative operator, D, interacts beautifully with this basis, dropping the degree by exactly one: D(t^n) = n t^{n - 1}. @@ -3736,7 +4050,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos When a person applies the discrete forward difference operator, Î´, to a falling factorial, it behaves identically to the continuous derivative: Î´(t^{\underline{n}}) = n t^{\underline{n - 1}}.

Stirling Numbers of the Second Kind, S(n, k)

+ + + + Stirling Numbers of the Second Kind, S(n, k)

The Stirling numbers of the second kind are the coefficients required to project the continuous basis onto the discrete basis. They express standard powers as a sum of falling factorials: @@ -3754,7 +4071,10 @@ 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.

Stirling Numbers of the First Kind, s(n, k)

+ + + + Stirling Numbers of the First Kind, s(n, k)

The signed Stirling numbers of the first kind perform the exact inverse operation. They reconstruct standard continuous powers from falling factorials: @@ -3775,6 +4095,9 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

They essentially prove that no information is lost when moving a polynomial from the abstract realm into the physical constraints of a stepping machine.

+ + + @@ -3782,110 +4105,10 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos - ---> diff --git a/document/book/TM-2026_parked.html b/document/book/TM-2026_parked.html new file mode 100644 index 0000000..62d4e89 --- /dev/null +++ b/document/book/TM-2026_parked.html @@ -0,0 +1,102 @@ + + more appendix mateial ... + +

Multiplication of synchronized difference vectors

+ +

+ Because the forward difference operator is linear, adding or subtracting two polynomials is achieved by the elementwise addition or subtraction of their initial difference vectors. Multiplication, however, requires a discrete convolution of the two vectors. +

+ +

+ Suppose a programmer has two initial difference vectors, A_0 representing function f(t) with an extent of \omega_a, and B_0 representing function g(t) with an extent of \omega_b. The goal is to compute the initial difference vector C_0 for the product function h(t) = f(t)g(t). +

+ +

+ Multiplying two polynomials of degrees \omega_a and \omega_b yields a polynomial of degree \omega_a + \omega_b. Therefore, the resulting vector C_0 will strictly have an extent of \omega_c = \omega_a + \omega_b, requiring a tape component count of \omega_a + \omega_b + 1. +

+ +

+ To determine the components of C_0 directly from A_0 and B_0 without evaluating the functions, we rely on the multiplication of their basis elements. In the calculus of finite differences, polynomials are expanded using binomial coefficients. The product of two binomial coefficients expands into a linear combination of higher binomial coefficients according to a known combinatorial identity: +

+ +

+ \binom{t}{i} \binom{t}{j} = \sum_{k=\max(i,j)}^{i+j} \binom{k}{i} \binom{i}{k-j} \binom{t}{k} +

+ +

+ By applying this identity across the summations of both input functions, the component k of the resulting vector C_0 can be computed algebraically. Each component C_{0, k} is the sum of the cross products of the input components, weighted by combinations of their indices: +

+ +

+ C_{0, k} = \sum_{i=0}^{\omega_a} \sum_{j=0}^{\omega_b} A_{0, i} B_{0, j} \binom{k}{i} \binom{i}{k-j} +

+ +

+ Thus, while a Turing Machine extending the function only requires a simple accumulator, a machine tasked with multiplying two initial tapes must perform a combinatorial cross multiplication to generate the expanded tape before the extension sequence can begin. +

+ +

Division and the Reciprocal Difference Vector

+ +

+ If the multiplication of two polynomials in the finite difference domain is a discrete convolution, then division is a discrete deconvolution. By finding the reciprocal of a difference vector, a programmer can perform division using the same combinatorial architecture. +

+ +

+ Let A_0 be the initial difference vector for a polynomial f(t). We seek the reciprocal difference vector C_0, which represents the function h(t) = 1/f(t). Because the reciprocal of a polynomial is a rational function, its forward differences will never reduce to zero. Thus, C_0 is an infinite vector. +

+ +

+ Following the lazy evaluation strategy, C_0 is not written to a static tape. It is implemented as a generator machine. The main evaluator queries this generator for its values up to the required extent \omega only as they are demanded. +

+ +

+ By definition, f(t)h(t) = 1. In the difference domain, this means the convolution of A_0 and C_0 must equal the identity vector I_0, where I_{0, 0} = 1 and all subsequent components are exactly zero. +

+ +

+ Recall the convolution formula for component k of the product: +

+ + + I_{0, k} = \sum_{i=0}^{k} \sum_{j=0}^{k} A_{0, i} C_{0, j} \binom{k}{i} \binom{i}{k-j} + + + +

+ To perform the deconvolution, we isolate the unknown component C_{0, k}. This term occurs in the summation strictly when j = k. When j = k, the term k-j equals 0, making the binomial coefficient \binom{i}{0} = 1. Factoring C_{0, k} out of the sum yields: +

+ + + C_{0, k} \sum_{i=0}^{k} A_{0, i} \binom{k}{i} + + +

+ A person familiar with Newton's forward difference formula will recognize that the summation \sum_{i=0}^{k} A_{0, i} \binom{k}{i} is exactly the evaluation of the original function at step k, or f(k). +

+ +

+ We can now solve for C_{0, k} recursively. For the base case k = 0, where I_{0, 0} = 1: +

+ + + C_{0, 0} = \frac{1}{A_{0, 0}} + + +

+ For all subsequent components where k > 0 and I_{0, k} = 0, we subtract the previously known terms of the convolution and divide by f(k): +

+ +

+ C_{0, k} = \frac{-1}{f(k)} \sum_{i=0}^{k} \sum_{j=0}^{k-1} A_{0, i} C_{0, j} \binom{k}{i} \binom{i}{k-j} +

+ +

+ This reveals a strict recurrent structure. To generate component k of the reciprocal vector, the generator machine relies entirely on the static components of the input polynomial A_0 and the previously computed components of the reciprocal C_{0, 0} through C_{0, k-1}. By encapsulating this recurrence within a generator, a programmer can perform exact division while maintaining finite memory bounds, extending the reciprocal vector only when the execution demands it. Note, this is a reciprocal of a function, rather than that of a value. +

+ + + ---------- + + in the original Turing machine Architecture, add three tapes, stdin, stdout, and stderr