From: Thomas Walker Lynch Date: Sat, 8 Aug 2026 15:48:23 +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%204.png?a=commitdiff_plain;h=b5a49d5a7d1116f0f43535bbb6dd3ed09cbfb78d;p=TM-2026 . --- diff --git a/document/book/TM-2026.html b/document/book/TM-2026.html index 0e78bac..307c98e 100644 --- a/document/book/TM-2026.html +++ b/document/book/TM-2026.html @@ -53,7 +53,7 @@ int x ,y ,z; - Code . A horizontal comma separated list + Code . A horizontal comma-separated list

Multi-level enclosures receive a single space of padding only on the outermost boundary:

@@ -80,7 +80,7 @@

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.

+

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.

@@ -169,7 +169,7 @@

- In 1928 David Hilbert and Wilhelm Ackermann published a textbook on mathematical logic, Grundzüge der theoretischen Logik David Hilbert and Wilhelm Ackermann, Grundzüge der theoretischen Logik (Berlin: Springer, 1928). This first edition has not been translated into English.. A feature of this book is its attention to procedures to follow for mechanically determining truth of statements. They called the problem solved by such a procedure the Entscheidungsproblem. In the first chapter they review the procedure for solving the Entscheidungsproblem in the propositional logic. For the first order predicate calculus they define the problem as, "Universal validity concerns the following question: How can one determine, for any given logical expression that contains no individual signs [constants], whether the expression represents a true assertion for arbitrary substitutions for the occurring variables, or not?" Ibid., 72–73.. They review some special cases with solutions, including one published earlier by Ackermann, but then throw down the gauntlet by saying, + In 1928 David Hilbert and Wilhelm Ackermann published a textbook on mathematical logic, Grundzüge der theoretischen Logik David Hilbert and Wilhelm Ackermann, Grundzüge der theoretischen Logik (Berlin: Springer, 1928). This first edition has not been translated into English.. A feature of this book is its attention to procedures to follow for mechanically determining truth of statements. They called the problem solved by such a procedure the Entscheidungsproblem. In the first chapter they review the procedure for solving the Entscheidungsproblem in the propositional logic. For the first-order predicate calculus they define the problem as, "Universal validity concerns the following question: How can one determine, for any given logical expression that contains no individual signs [constants], whether the expression represents a true assertion for arbitrary substitutions for the occurring variables, or not?" Ibid., 72–73.. They review some special cases with solutions, including one published earlier by Ackermann, but then throw down the gauntlet by saying, "A general solution to the Entscheidungsproblem, regardless of whether a person considers the first or the second formulation, is not yet available." Ibid., 81. "Eine allgemeine Lösung des Entscheidungsproblems, mag man nun die erste oder die zweite Fassung nehmen, liegt bis jetzt noch nicht vor." The term Entscheidungsproblem literally translates to 'decision problem'. However, there are many types of decision problems, and later we will meet a class of Turing Machine programs called deciders, so it appears to be best to keep the original German. As we will see later Alan Turing also did this..

@@ -182,7 +182,7 @@

- Alan Turing used an abstraction of a computing machine, also described as a clerk working at a desk with pen and squares on paper while following a procedure, to prove that no primary analyzer program can universally decide whether a second analyzed program will halt when it is run Ibid.. An answer to this halting problem (specifically asserting "The analyzed machine halts" or "The analyzed machine does not halt") would indeed be a statement in first order logic. Thus, by showing no analyzer can universally make such a determination, Turing proved that no decider could exist for the Entscheidungsproblem. + Alan Turing used an abstraction of a computing machine, also described as a clerk working at a desk with pen and squares on paper while following a procedure, to prove that no primary analyzer program can universally decide whether a second analyzed program will halt when it is run Ibid.. An answer to this halting problem (specifically asserting "The analyzed machine halts" or "The analyzed machine does not halt") would indeed be a statement in first-order logic. Thus, by showing no analyzer can universally make such a determination, Turing proved that no decider could exist for the Entscheidungsproblem.

@@ -408,7 +408,7 @@

- By definition, first order analysis is the running of programs, and it has its place. + 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.

@@ -417,7 +417,7 @@

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

@@ -600,9 +600,9 @@

  • Σ: The finite set of input symbols.
  • Γ: The complete set of tape symbols; Σ is always a subset of Γ.
  • □: The empty symbol. This symbol belongs exclusively to Γ, serving as a distinct tape marker rather than an input symbol. The empty symbol initially populates all cells except the finite number containing the input symbols.
    • -
  • δ: The next state function. The arguments of δ(q, X) are a state q and a tape symbol X. The value of δ(q, X), if it is defined, is a triple (p, Y, D), where: +
  • δ: The next-state function. The arguments of δ(q, X) are a state q and a tape symbol X. The value of δ(q, X), if it is defined, is a triple (p, Y, D), where:
      -
    1. p is the next state in Q.
      2. +
    2. p is the next-state in Q.
    3. Y is the symbol in Γ written in the scanned cell, replacing the previous symbol.
    4. D is a direction, either L or R, standing for "left" or "right," respectively, directing the head to move either left or right.
    @@ -618,9 +618,9 @@

    Here the input alphabet is said to be a subset of a larger alphabet. This allows some symbols to be set aside and only used by the machine. The symbols which are exclusive to the larger set are control symbols. control symbols symbols are distinguished by their use in describing the machine status rather than serving explicitly as input data. Hopcroft and Ullman include the empty symbol, □, as a control symbol. However, they have simultaneously listed it as a separate component.

    -

    State transitions are gated by the value read from the tape. Each state transition is bound to an action to be taken by the machine; hence, this Turing Machine definition describes a Mealy style state machine. Structurally, this action specifies two distinct instructions. First, it is mandatory that exactly one of the two step instructions, left or right, be issued. Second, a write(σ) instruction must also be specified, though the written symbol can be the same symbol that is read, making the write operation effectively optional.

    +

    State transitions are gated by the value read from the tape. Each state transition is bound to an action to be taken by the machine; hence, this Turing Machine definition describes a Mealy style state machine. Structurally, this action specifies two distinct instructions. First, it is mandatory that exactly one of the two-step instructions, left or right, be issued. Second, a write(σ) instruction must also be specified, though the written symbol can be the same symbol that is read, making the write operation effectively optional.

    -

    This machine makes use of a single ended tape. If a computation specifies a two way infinite tape, it can be emulated by interleaving the addresses: assigning odd addressed cells to represent the right going half, and even addressed cells to represent the left going half. This emulation requires taking two steps instead of one to advance in a given logical direction, and to wrap motion at the dividing cell, and is otherwise undetectable. The transformation has a small constant effect at the dividing cell, and otherwise multiplies the step count formula by two, which do not affect big O results. Hence, the single ended tape machine is a computation theoretic inconsequential variation of the two way tape machine. +

    This machine makes use of a single-ended tape. If a computation specifies a two way infinite tape, it can be emulated by interleaving the addresses: assigning odd addressed cells to represent the right going half, and even addressed cells to represent the left going half. This emulation requires taking two steps instead of one to advance in a given logical direction, and to wrap motion at the dividing cell, and is otherwise undetectable. The transformation has a small constant effect at the dividing cell, and otherwise multiplies the step-count formula by two, which do not affect big O results. Hence, the single-ended tape machine is a computation theoretic inconsequential variation of the two way tape machine.

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

    This shows string reversal to be an O(n^2) complexity problem, which might appear to some programmers as a peculiar result, as the same problem can be solved in O(n) time with a C program. This justifies further analysis.

    -

    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.

    +

    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:

    @@ -887,11 +887,11 @@ eq: An empty tape written as a sequence of empty sets -

    Here, each tape member set is called a cell. This definition for an empty tape is specific to Turing Machines, as in mathematics an empty sequence has zero length. An empty tape is not an empty sequence, rather it is an infinite sequence where every member is an empty set. In one sense this is a little peculiar that something said to be empty is infinite, in another sense it is consistent for the model that an empty Turing Machine tape keeps its defining characteristics. That is, it remains a single ended Turing Machine tape, where any cell of the tape could be written with a symbol value, while the basic form of the tape will not change.

    +

    Here, each tape member set is called a cell. This definition for an empty tape is specific to Turing Machines, as in mathematics an empty sequence has zero length. An empty tape is not an empty sequence, rather it is an infinite sequence where every member is an empty set. In one sense this is a little peculiar that something said to be empty is infinite, in another sense it is consistent for the model that an empty Turing Machine tape keeps its defining characteristics. That is, it remains a single-ended Turing Machine tape, where any cell of the tape could be written with a symbol value, while the basic form of the tape will not change.

    -

    A conventionally defined Turing Machine will break if reading a cell does not yield a symbol, because the next state function has the read symbol as an argument.

    +

    A conventionally defined Turing Machine will break if reading a cell does not yield a symbol, because the next-state function has the read symbol as an argument.

    -

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

    +

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

    @@ -964,15 +964,15 @@ 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.

    +

    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.

    -

    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.

    +

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

    -

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

    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.

    @@ -1021,7 +1021,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:

    @@ -1030,18 +1030,18 @@
  • Conditional (Δ_0): Selects the transition rule that matches the current state and the value of the status register.
  • State Default (Δ_1): Selects the default transition rule that matches the current state.
  • Status Default (Δ_2): Selects the default transition rule that matches the current machine status.
    • -
  • Global Default (Δ_3): A single table that holds the next state of last resort.
    • +
  • Global Default (Δ_3): A single table that holds the next-state of last resort.
    • - List . The four next state transition layers, in evaluation order + List . The four next-state transition layers, in evaluation order -

    Programmers will typically use the Global Default arc, Δ_3, to take the machine to an error state when they have mistakenly left the next state transition undefined. However, it is conceivable for some machines that if no other next state is defined, there is a single logical state that should be visited, and this condition is not an error. If no Global Default arc is specified, and no next state is found, the machine hangs.

    +

    Programmers will typically use the Global Default arc, Δ_3, to take the machine to an error state when they have mistakenly left the next-state transition undefined. However, it is conceivable for some machines that if no other next-state is defined, there is a single logical state that should be visited, and this condition is not an error. If no Global Default arc is specified, and no next-state is found, the machine hangs.

    This approach of cascading next-state decisions does more than merely make the machine more convenient to program; it also enables a programmer to support an unspecified symbol. For example, a programmer can incorporate a first-order unspecified symbol by first adding it to the alphabet Σ, adding a Q_unspecified state to Q, and then adding a status default arc to Δ_2 of \langle \mathtt{s{·}unspecified}, \mathit{Q\_unspecified} \rangle. Finally, the programmer adds Q_unspecified to the set of halting states. Then, if the machine attempts to make a decision upon the unspecified symbol, the machine will transition to the Q_unspecified state and halt. Such a machine can then be analyzed to see if it ever visits the Q_unspecified state, although the analyst must take care, because if he puts some thought into this, he will realize that no such universal analyzer can exist.

    The formal definition that follows will be partitioned according to the separation of concerns. The first section defines the fixed parts of the Turing Machine definition. The second section defines the memory elements (variables). The third section describes the programmable components, which vary between specific Turing Machines depending on their purposes.

    -

    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.

    +

    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.

    @@ -1180,7 +1180,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:

    @@ -1192,7 +1192,7 @@ eq: Δ₁, the state default transition table -

    where q_i is matched to the current state, and upon a match q_{i+1} will be taken as the next state.

    +

    where q_i is matched to the current state, and upon a match q_{i+1} will be taken as the next-state.

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

    @@ -1204,19 +1204,19 @@ eq: Δ₂, the status default transition table -

    where σ matches the symbol in s register, and upon a match q_{i+1} will be taken as the next state.

    +

    where σ matches the symbol in s register, and upon a match q_{i+1} will be taken as the next-state.

    -

    The global default next state:

    +

    The global default next-state:

    Δ_3 = q_{i+1} - eq: Δ₃, the global default next state + eq: Δ₃, the global default next-state -

    This is the transition of last resort. It is unconditional; the next state becomes q_{i+1}.

    +

    This is the transition of last resort. It is unconditional; the next-state becomes q_{i+1}.

    A set of programmer-defined halting states:

    @@ -1285,7 +1285,7 @@ eq: Λ, the instruction table, entirely programmed -

    The ordered sequence of next state transition rules:

    +

    The ordered sequence of next-state transition rules:

    @@ -1315,7 +1315,7 @@

    The executor takes the TTCA machine through three stages of execution: initialization, programmed control, and halting. While going through these stages, the executor gives the \mathit{MV} variables values.

    -

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

    +

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

    Initialization stage @@ -1351,7 +1351,7 @@ 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.

    +

    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.

         @@ -1714,7 +1714,7 @@ δ: Q·Done - Code . The two headed string reverse controller + Code . The two-headed string reverse controller     @@ -1723,7 +1723,7 @@
    TTCAM 2 hd reverse machine
    - Figure . A two headed TTCA Machine that reverses a binary string + Figure . A two-headed TTCA Machine that reverses a binary string     @@ -1743,7 +1743,7 @@ 9n + 4 & \text{if } n \ge 1 \end{cases} - eq: Steps taken by the two headed TTCA reverse machine + eq: Steps taken by the two-headed TTCA reverse machine

    The two paths through the state machine, and the one loop, translate well into code:

    @@ -1790,14 +1790,14 @@ return; } - Code . The two headed reverse controller written as C + 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.

    -

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

    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.

    @@ -1920,7 +1920,7 @@ | RUN/STEP [/] ○ STEP { } | +-----------------------------------+ - Figure . The control panel, carrying power, error, reset and single step + Figure . The control panel, carrying power, error, reset and single-step @@ -1986,7 +1986,7 @@ Figure . The sigma select panel, choosing the symbol written by write(σ) -

    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.

    +

    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.

    The second section is the state transition panel. At the top of this panel are the state indicator lights and a row of halting toggles; if flipped closed, the corresponding state becomes a halting state. Below this is the transition condition matrix, consisting of holes that fit the banana plug ends of a patch cord. Each column corresponds to a current state, and each row corresponds to a status symbol.

    @@ -2020,7 +2020,7 @@
    1. Control Panel
        -
      1. Power Switch, Single Step Switch, Reset Button, Single Step Button
        2. +
      2. Power Switch, Single-Step Switch, Reset Button, Single-Step Button
      3. patch cord matrices
      2. @@ -2040,13 +2040,13 @@
  • Clock logic and distribution lines (clk)
    • -
  • Single Step Switch single shot logic
    • +
  • Single-Step Switch single shot logic
  • CPCU (Customer Programmed Control Unit)
    1. One-hot q register
      2. -
    2. Next State Table
      3. +
    3. Next-State Table
    4. Instruction Table
    • @@ -2060,17 +2060,17 @@

    As described in chapter , which is being used as the architectural template, the executor guides the machine through the initialization, programmed control, and halting stages of execution. The Executor contains the power, reset, and clock logic. It has two modes of execution: the run mode in which the clock runs free, and the single-step mode, in which clock pulses are sent with the push of a button. It also holds the halt state switch bank, and is ready to stop the clock when a halt state is reached. When in the programmed control stage, most of the active control comes from the CPCU.

    -

    The CPCU contains the current state register q, the Next State Table, and the Instruction Table.

    +

    The CPCU contains the current state register q, the Next-State Table, and the Instruction Table.

    The output of the Instruction Table provides primary control of the running machine. Its output determines which of the TTUs will be active and which head in the TTU is to be used. The machine has an internal data bus. The output of the Instruction Table also determines which TTU register will drive that bus, and which register will receive data from the bus.

    -

    The register file contains two registers, s and d. Both can receive values from the internal data bus or drive values onto that bus. The d register is not connected to any other units, so it can not participate in the next-state decision process. It can however, be an argument in a subsequent write instruction, causing its value to go back out on the data bus, then to an HU, and then be put back on the tape. The s register is connected directly to the Status Decode, and that in turn is connected directly to the next state logic. The s register can also drive the data bus.

    +

    The register file contains two registers, s and d. Both can receive values from the internal data bus or drive values onto that bus. The d register is not connected to any other units, so it can not participate in the next-state decision process. It can however, be an argument in a subsequent write instruction, causing its value to go back out on the data bus, then to an HU, and then be put back on the tape. The s register is connected directly to the Status Decode, and that in turn is connected directly to the next-state logic. The s register can also drive the data bus.

    -

    The symbols of the alphabet are enumerated such that each symbol corresponds to a specific row index on the control panel. The value of the s register is decoded, resulting in a one-hot encoding of the status symbol. This one-hot encoding then goes to the Next State Table in the CPCU and illuminates one of the rows. The q register enumerates the columns. If a patch cord is plugged into that intersection point and leads to the destination state row below, then the state selected becomes the next state for the machine.

    +

    The symbols of the alphabet are enumerated such that each symbol corresponds to a specific row index on the control panel. The value of the s register is decoded, resulting in a one-hot encoding of the status symbol. This one-hot encoding then goes to the Next-State Table in the CPCU and illuminates one of the rows. The q register enumerates the columns. If a patch cord is plugged into that intersection point and leads to the destination state row below, then the state selected becomes the next-state for the machine.

    The current state register q utilizes a one-hot encoding, allocating a discrete bit per state. A control line from each bit routes to the Halt Switch Bank within the executor, where the outputs are wire-ORed together to generate the master halt signal. Consequently, a halt condition asserts if and only if the currently active state bit corresponds to an enabled toggle in the switch bank. The output of the q register also selects a row in the Instruction Table, and this is key to controlling the machine.

    -

    Upon reset, the current state register initializes to a one-hot configuration with the bit for state q_0 asserted, while all other machine registers clear to zero. Uncontrolled power-up could trap the machine in an illegal configuration where it would ignore subsequent reset instructions or even induce physical hardware damage. To prevent initialization hazards, the power switch incorporates a capacitor timer that maintains an active reset signal until supply voltages fully stabilize. When in run mode, the machine will begin running after reset is released. In single step mode, it will then wait for a push of the single step button.

    +

    Upon reset, the current state register initializes to a one-hot configuration with the bit for state q_0 asserted, while all other machine registers clear to zero. Uncontrolled power-up could trap the machine in an illegal configuration where it would ignore subsequent reset instructions or even induce physical hardware damage. To prevent initialization hazards, the power switch incorporates a capacitor timer that maintains an active reset signal until supply voltages fully stabilize. When in run mode, the machine will begin running after reset is released. In single-step mode, it will then wait for a push of the single-step button.

    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. @@ -2079,7 +2079,7 @@ 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.

    +

    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.

    On the rising edge of the clock, the new current state signal ripples through the Instruction Table. As the q register is stored as a one-hot value, this happens very quickly. Rather than placing instructions in the Instruction Table, the decoded values to be used as control signals are programmed directly into the table. Among the decoded outputs is a control signal that enables the status register to sample when the clock falls.

    @@ -2087,7 +2087,7 @@

    Thus the status register in the selected TTU and HU will be driving the data bus, and the machine s register is ready to sample the bus. Then the clock falls, the s register updates, and holds its value until the next time when it is enabled to update and the clock falls.

    -

    The updated value in the s register then drives the Next State Table rows. The column lines stabilized earlier in the cycle, immediately after the state updated. If a patch cord is plugged in at the intersection of the row and the column, then a signal will travel through that cord to the next state row that is located below the state and status matrix. Then when the clock rises again, this signal, which is held steady by the driving status register, will be sampled and become the next state.

    +

    The updated value in the s register then drives the Next-State Table rows. The column lines stabilized earlier in the cycle, immediately after the state updated. If a patch cord is plugged in at the intersection of the row and the column, then a signal will travel through that cord to the next-state row that is located below the state and status matrix. Then when the clock rises again, this signal, which is held steady by the driving status register, will be sampled and become the next-state.

    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.

    @@ -2110,7 +2110,7 @@

    The left neighbor cell to the leftmost cell of a given area is considered to be the left neighbor cell to the area. Similarly, the right neighbor cell to the rightmost cell of a given area is considered to be the right neighbor cell to the area. If the given area is located at the left end of the tape, then it has no left neighbor cell. If the given area is open on the right, then it has no right neighbor cell.

    -

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

    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.

    @@ -2182,7 +2182,7 @@ 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. + 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.

    @@ -2215,7 +2215,7 @@

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

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

    +

    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.

    -

    So then can we add a property to cardinality, such that a second order analysis could use this property to continue downstream analysis? In short we could say that cardinality has no first order value, but it has a second order one. This is analogous to inventing a new type of number, analogous to a complex number with a second component. I.e., there is no 'real' solution, but there is an 'imaginary' one. Or analogous to error algebra, where a number value is replaced with a rule on how to handle downstream operations when it is given as an input. +

    So then can we add a property to cardinality, such that a second-order analysis could use this property to continue downstream analysis? In short we could say that cardinality has no first-order value, but it has a second-order one. This is analogous to inventing a new type of number, analogous to a complex number with a second component. I.e., there is no 'real' solution, but there is an 'imaginary' one. Or analogous to error algebra, where a number value is replaced with a rule on how to handle downstream operations when it is given as an input.

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

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

    - The Natural Number found on A_P is then called the address for the cell that machine P's head is on. As each increment and decrement of the address is a constant time operation, keeping the address of the cell the head is on is computationally inconsequential. + The Natural Number found on A_P is then called the address for the cell that machine P's head is on. As each increment and decrement of the address is a constant-time operation, keeping the address of the cell the head is on is computationally inconsequential.

    @@ -2493,7 +2493,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.

    @@ -2519,7 +2519,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos Code . A controller that increments a binary counter -

    Here TTU is the tape transport unit. It has the number to be incremented mounted on it. This number is either zero, which would mean the leftmost cell is empty, or it is of the same form as a result from a Natural Number extension machine. A TTU.read places a copy of the symbol instance found in the cell under the head into the read buffer automatically when the machine enters a new state on the programmed controller, so it is not counted as a step. In contrast, the other actions are associated with the state of the programmed controller, so when the machine arrives at a write, step, or halt node, it means that the programmed state controller has taken a step. Sequential instructions mean unconditional next state choices, whereas an if signals a conditional next state choice. The if condition is a logical proposition based on the read symbol.

    +

    Here TTU is the tape transport unit. It has the number to be incremented mounted on it. This number is either zero, which would mean the leftmost cell is empty, or it is of the same form as a result from a Natural Number extension machine. A TTU.read places a copy of the symbol instance found in the cell under the head into the read buffer automatically when the machine enters a new state on the programmed controller, so it is not counted as a step. In contrast, the other actions are associated with the state of the programmed controller, so when the machine arrives at a write, step, or halt node, it means that the programmed state controller has taken a step. Sequential instructions mean unconditional next-state choices, whereas an if signals a conditional next-state choice. The if condition is a logical proposition based on the read symbol.

    The loop form here is worth taking note of, as it will come up again. The controller executes a first action, that of a read, followed by a middle break test, and then the recursive form actions.

    @@ -2603,18 +2603,18 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos \text{Average Cost} = 4 - \frac{2n}{2^n - 1}

    - As the address space grows, the bit width n increases. The polynomial term 2n is outpaced by the exponential denominator 2^n - 1, causing the fractional terms to converge to zero. The average work done by the machine head converges to exactly four tape actions per increment. Constant time, same as for unary. This is a surprising counter intuitive result. + As the address space grows, the bit width n increases. The polynomial term 2n is outpaced by the exponential denominator 2^n - 1, causing the fractional terms to converge to zero. The average work done by the machine head converges to exactly four tape actions per increment. constant-time, same as for unary. This is a surprising counter intuitive result.

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

    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.

    +

    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.

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

    In many contexts, a person drops the container notation without causing ambiguity. Conventionally, dropping the notation reverses the order of the components. The sequence from the prior example, X = [7, 8, 9], becomes x = 987. To be clear, note that this number is 13 away from a thousand.

    -

    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.

    +

    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.

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

    To make the structure uniform, Western writers must either start writing right to left like the Arabs do, or reverse the order of digits in numbers. Computer architects implemented this latter option; for example, Intel processors utilize it.

    -

    In summary, this section defines two concepts: scanning-order when reading, and the digit-order of numbers. Changing the scanning order without changing the digit order effectively causes the number to be read in reverse.

    +

    In summary, this section defines two concepts: scanning-order when reading, and the digit-order of numbers. Changing the scanning-order without changing the digit-order effectively causes the number to be read in reverse.

    -

    All conventional computers use low-to-high address scanning order for writing and reading text. Human operators universally find that low-to-high address scanning order for text feels natural. Relative to the low-to-high address scanning order, Big Endian computers follow the current Western ideal that the large digit comes first. In contrast, Little Endian computers are more faithful to the design of Hindu-Arabic numbers, storing numbers consistently with the scanning order matching the order of the digit weights.

    +

    All conventional computers use low-to-high address scanning-order for writing and reading text. Human operators universally find that low-to-high address scanning-order for text feels natural. Relative to the low-to-high address scanning-order, Big-Endian computers follow the current Western ideal that the large digit comes first. In contrast, Little-Endian computers are more faithful to the design of Hindu-Arabic numbers, storing numbers consistently with the scanning-order matching the order of the digit weights.

    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.

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

    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.

    -

    Consider recording a count in real time, where the system must routinely erase the current count value and write a new one. The process begins at zero. When an event occurs, the count increments to 1. The sequence remains a single digit. The count grows to two digits in length upon reaching ten. The count grows by another digit in length upon reaching a hundred, and again at a thousand. A digit sequence representing the count grows in length against the log of the count value. The log function grows without bound, but it does so slowly, allowing relatively short digit sequences to represent exceedingly large numbers. This structural observation is central to understanding contemporary computer architecture.

    +

    Consider recording a count in real-time, where the system must routinely erase the current count value and write a new one. The process begins at zero. When an event occurs, the count increments to 1. The sequence remains a single digit. The count grows to two digits in length upon reaching ten. The count grows by another digit in length upon reaching a hundred, and again at a thousand. A digit sequence representing the count grows in length against the log of the count value. The log function grows without bound, but it does so slowly, allowing relatively short digit sequences to represent exceedingly large numbers. This structural observation is central to understanding contemporary computer architecture.

    If a paper document only provides space for a single digit count, an error occurs when the count grows to ten, escalating when it reaches a thousand. If a programmer anticipates counts in the thousands, he allocates space for four digits in advance. Such an allocation minimizes wasted space because the digit sequences for massive numbers are not significantly longer than those for small numbers.

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

    It follows that any larger allocation consists of multiple bytes. For a given allocation unit, the smallest address among the contained bytes establishes the address of the allocation unit. Each allocation unit is bounded by two parameters: its address, and its extent.

    -

    Setting aside the scanning order variable, a number logically begins with its least-significant digit. This is justified because an analyst must read a number starting with its least-significant digit to derive the weights of the subsequent digits. The allocation scheme where the address of the allocation maps to the address of the least-significant digit is called little-endian. The definition of big-endian involves zero-padding to fulfill the allocation width. Relative to starting at the least-significant digit, the big-endian allocation address resolves to either the most-significant digit or the final zero in the padding.

    +

    Setting aside the scanning-order variable, a number logically begins with its least-significant digit. This is justified because an analyst must read a number starting with its least-significant digit to derive the weights of the subsequent digits. The allocation scheme where the address of the allocation maps to the address of the least-significant digit is called little-endian. The definition of big-endian involves zero-padding to fulfill the allocation width. Relative to starting at the least-significant digit, the big-endian allocation address resolves to either the most-significant digit or the final zero in the padding.

    -

    In the architectural terminology utilized here, viewing memory as a horizontal tape with bytes in the cells and addresses increasing while moving to the right, little-endian numbers have the least-significant digit on the left, and big-endian numbers have the least significant digit on the right of an allocation. Stated structurally, little-endian numbers are zero padded on the right, and big-endian numbers are zero padded on the left.

    +

    In the architectural terminology utilized here, viewing memory as a horizontal tape with bytes in the cells and addresses increasing while moving to the right, little-endian numbers have the least-significant digit on the left, and big-endian numbers have the least-significant digit on the right of an allocation. Stated structurally, little-endian numbers are zero padded on the right, and big-endian numbers are zero padded on the left.

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

    @@ -2835,9 +2835,9 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos
    - Figure 11: Same number using big-endian digit order + Figure 11: Same number using big-endian digit-order
    - Figure . The same number held in big-endian digit order + Figure . The same number held in big-endian digit-order

    If the specified word holds a count, the counting mechanics differ. When counting with the little-endian convention, a number grows into larger addresses as the count carries into new digits. In contrast, with big-endian architecture, counting carries into strictly smaller memory addresses.

    @@ -2846,7 +2846,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.

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

    Some processors physically store bits into memory bytes in different orders. However, the data read and written into the respective memories routes through a bus, and at that boundary, the bit order aligns with the applicable bus specification.

    -

    On all contemporary computers, ALU hardware performs arithmetic on bytes. Carries propagate strictly from lower significant bits to more significant bits; therefore, the ALU imposes a logical bit order within bytes. That logical order conforms directly to the documentation for the processor’s internal bus, where bit 0 serves universally as the least significant bit.

    +

    On all contemporary computers, ALU hardware performs arithmetic on bytes. Carries propagate strictly from lower significant bits to more significant bits; therefore, the ALU imposes a logical bit order within bytes. That logical order conforms directly to the documentation for the processor’s internal bus, where bit 0 serves universally as the least-significant bit.

    -

    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.

    +

    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.

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

    - Would it be computationally consequential if binary Hindu-Arabic representation were used instead of unary for addresses? For unary representation each increment was constant time, but with Hindu-Arabic addresses, increments have a carry. Would the carry cause stepping to the right, combined with calling the address machine, to become slower and slower as the machine steps further and further? + Would it be computationally consequential if binary Hindu-Arabic representation were used instead of unary for addresses? For unary representation each increment was constant-time, but with Hindu-Arabic addresses, increments have a carry. Would the carry cause stepping to the right, combined with calling the address machine, to become slower and slower as the machine steps further and further?

    @@ -2931,7 +2931,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.

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

    - There will, however, be a more dominant effect. For programs with islands of locality of reference, instructions or data will be discovered in a cache. Caches bring in two types of locality: that of access within a cache line, which makes neighbor walks that stay in the line fast, and cache line prefetch and replacement policies, which assume for any given fetch address that a subsequent fetch will be nearby in memory. These effects lead to similar memory behavior as a head on tape, where a single step to a neighbor is faster than taking many steps to find memory further away, but there is not a one to one correspondence. + There will, however, be a more dominant effect. For programs with islands of locality of reference, instructions or data will be discovered in a cache. Caches bring in two types of locality: that of access within a cache line, which makes neighbor walks that stay in the line fast, and cache line prefetch and replacement policies, which assume for any given fetch address that a subsequent fetch will be nearby in memory. These effects lead to similar memory behavior as a head on tape, where a single-step to a neighbor is faster than taking many steps to find memory further away, but there is not a one to one correspondence.

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

    - In summary then, using Hindu-Arabic representation for addressing is not statistically computationally consequential. On the other hand, the idea of using a decoded address in place of a tape head raises computational model issues. So much so that it would not be an exaggeration to say that the very goal of modern computer architecture is to ensure that, within an execution context, address decode does not become computationally consequential. Architects employ a memory hierarchy to do this, and that memory hierarchy rewards locality of reference, but access times are not linear in time relative to distance from prior access. Instead they are clumped into a constant time access abstract concept of locality groups where the time to access each group grows exponentially with the distance from the processor. + In summary then, using Hindu-Arabic representation for addressing is not statistically computationally consequential. On the other hand, the idea of using a decoded address in place of a tape head raises computational model issues. So much so that it would not be an exaggeration to say that the very goal of modern computer architecture is to ensure that, within an execution context, address decode does not become computationally consequential. Architects employ a memory hierarchy to do this, and that memory hierarchy rewards locality of reference, but access times are not linear in time relative to distance from prior access. Instead they are clumped into a constant-time access abstract concept of locality groups where the time to access each group grows exponentially with the distance from the processor.

    @@ -3030,13 +3030,13 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

    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.

    -

    The only information that the first tape of a Universal Machine need contain is the variable part, \mathit{MP}, which the text established as the program, as the remainder of the definition is common to all machines and can thus be built into the controller. \mathit{MP} describes a state controller, it lists the states, the symbols of the alphabet, the instruction to be issued from each state, the symbol gated next state transitions, and the halting state. The Universal Machine control program would then have to interpret that information and send the universal machine through the same steps that a human executor would take while running the described machine.

    +

    The only information that the first tape of a Universal Machine need contain is the variable part, \mathit{MP}, which the text established as the program, as the remainder of the definition is common to all machines and can thus be built into the controller. \mathit{MP} describes a state controller, it lists the states, the symbols of the alphabet, the instruction to be issued from each state, the symbol gated next-state transitions, and the halting state. The Universal Machine control program would then have to interpret that information and send the universal machine through the same steps that a human executor would take while running the described machine.

    However, the controller can be simplified if the program encoding is changed from the raw definition. Notice that the only information that leaves the state controller while it runs are the instructions issued per state, with that list terminating when the controller reaches the halt state.

    Imagine then, mounting a tape on a given machine, running the machine, and recording the instructions that leave the controller up until it halts. Then taking that list of instructions, and the same input tape, and mounting them on a Playback Machine. The Playback Machine then takes the instructions from the list on the first tape and issues them out of its own controller one by one. The playback controller is quite simple. Though of course, this approach has the drawback of having to run the given machine first so as to observe it, thus making the playback run moot.

    -

    Consider then, inserting jump table instructions to handle the next state transitions. Then a state controller can be mechanically changed into an instruction sequence with embedded jump table instructions without having to run it and observe it. Accordingly, first examine the state diagram for the controller. Take all the sequential state runs, even those of length 1, from the controller, and list their instructions in the same sequence order. Then, after each such sequence, wherever a state has next state transition arcs based on the value of the status register, insert a jump table instruction, so that it jumps to the appropriate instruction sequence.

    +

    Consider then, inserting jump table instructions to handle the next-state transitions. Then a state controller can be mechanically changed into an instruction sequence with embedded jump table instructions without having to run it and observe it. Accordingly, first examine the state diagram for the controller. Take all the sequential state runs, even those of length 1, from the controller, and list their instructions in the same sequence order. Then, after each such sequence, wherever a state has next-state transition arcs based on the value of the status register, insert a jump table instruction, so that it jumps to the appropriate instruction sequence.

    Applying this mechanical procedure to the TTCA two-headed reverse string example controller results in:

    @@ -3091,7 +3091,7 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos write('σ' ,1 ,EOR) halt - Code . The two headed reverse controller as linear code with jumps + Code . The two-headed reverse controller as linear code with jumps

    The state labels have become addresses into the program tape, and the address of the cell indicated by the head on the first tape is now an Instruction Pointer (IP). In a sense the programmed controller has been replaced by a little Turing Machine of its own. One that controls the head on the first tape, and moves it in response to the control instructions found on the first tape. Such a controller on a processor is called a sequencer.

    @@ -3261,11 +3261,11 @@ 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.

    - However, this is feels unsatisfactory. Here we are tying to build a bridge from computation theory to architecture, and thus we want a step to be a constant time occurrence at least in the average, or at least approximately. To model the symbol copy time, a symbol could be copied a tranche of bits per step, thus giving the copy a step count. Then, if symbols were to grow in tranche count as a program ran longer, then symbol copy of ever longer symbols would be computationally consequential. + However, this is feels unsatisfactory. Here we are tying to build a bridge from computation theory to architecture, and thus we want a step to be a constant-time occurrence at least in the average, or at least approximately. To model the symbol copy time, a symbol could be copied a tranche of bits per step, thus giving the copy a step-count. Then, if symbols were to grow in tranche count as a program ran longer, then symbol copy of ever longer symbols would be computationally consequential.

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

    The orders of analysis were named in section . This - chapter takes the second order as its working material. + chapter takes the second-order as its working material.

    @@ -3496,29 +3496,29 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos

    - As an analyzer does not run the machine being analyzed, it is not required to be a machine that halts. Suppose we have a machine that produces an infinite sequence of digits to a tape without halting. A limit analyzer could examine that machine and, in some cases, determine if it has asymptotic behavior. For example, recognizing that appending a binary fractional sequence of 0.1111... indefinitely evaluates in the limit to 1.0. In this manner, the use of analyzers facilitates using computation theory for deriving higher order mathematics. + As an analyzer does not run the machine being analyzed, it is not required to be a machine that halts. Suppose we have a machine that produces an infinite sequence of digits to a tape without halting. A limit analyzer could examine that machine and, in some cases, determine if it has asymptotic behavior. For example, recognizing that appending a binary fractional sequence of 0.1111... indefinitely evaluates in the limit to 1.0. In this manner, the use of analyzers facilitates using computation theory for deriving higher-order mathematics.

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

    - Let us employ Boehm and Cartwright's constructive real numbers, though in second order arithmetic rather than a lazy evaluation system. Because we are doing second order arithmetic, our programs need not be in the form of generators that yield a new value when called, but can be arbitrary programs containing complex control logic. If run, they evaluate physical conditions and produce results. As we are in the second order, however, we will not run them, but rather analyze and manipulate their structural logic. + Let us employ Boehm and Cartwright's constructive real numbers, though in second-order arithmetic rather than a lazy evaluation system. Because we are doing second-order arithmetic, our programs need not be in the form of generators that yield a new value when called, but can be arbitrary programs containing complex control logic. If run, they evaluate physical conditions and produce results. As we are in the second-order, however, we will not run them, but rather analyze and manipulate their structural logic.

    - Consider an illustrative example. We start by defining a fundamental language for communicating with the head and tape transport unit. The statements we communicate to our tape transport unit will be explicit physical instructions: (step), (left), (read), and (write symbol). In the first order, evaluating these instructions physically actuates the tape. + Consider an illustrative example. We start by defining a fundamental language for communicating with the head and tape transport unit. The statements we communicate to our tape transport unit will be explicit physical instructions: (step), (left), (read), and (write symbol). In the first-order, evaluating these instructions physically actuates the tape.

    - Suppose our goal is to subtract 3 from 5 in the second order. Consider a Turing Machine representation named five that outputs the number 5, i.e., it prints to the tape, 'sssss', using unary notation. Let us assume that the tape is initially empty and that the empty symbol '□' terminates the string. To preserve the code for second order analysis, we define the program's Abstract Syntax Tree (AST) as a quoted progn block. This block can contain any native Lisp control structures, though for this generator it is a simple sequence: + Suppose our goal is to subtract 3 from 5 in the second-order. Consider a Turing Machine representation named five that outputs the number 5, i.e., it prints to the tape, 'sssss', using unary notation. Let us assume that the tape is initially empty and that the empty symbol '□' terminates the string. To preserve the code for second-order analysis, we define the program's Abstract Syntax Tree (AST) as a quoted progn block. This block can contain any native Lisp control structures, though for this generator it is a simple sequence:

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

    - If we were to dynamically evaluate these ASTs in the first order, the Hindu-Arabic representation of each number would be physically written in unary code on the tape. + If we were to dynamically evaluate these ASTs in the first-order, the Hindu-Arabic representation of each number would be physically written in unary code on the tape.

    - For the second order difference operation, we compose the ASTs to create a new program. Here we extract the body of the second operand's AST and substitute every (write s) followed by a (step) instruction with an inverted pair: a (left) instruction followed by writing the empty symbol (write □). + For the second-order difference operation, we compose the ASTs to create a new program. Here we extract the body of the second operand's AST and substitute every (write s) followed by a (step) instruction with an inverted pair: a (left) instruction followed by writing the empty symbol (write □).

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

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

    - Let us take the multiplicative inverse of the additive identity as an example, AKA division by zero. In the second order, when we attempt to compute a division, say 6/0, the machine will not reduce. + Let us take the multiplicative inverse of the additive identity as an example, AKA division by zero. In the second-order, when we attempt to compute a division, say 6/0, the machine will not reduce.

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

    - The mechanical application of finite differences was famously leveraged by Charles Babbage in the design of his Difference Engine. By examining the discrete changes between consecutive outputs of a polynomial function, a person can observe that the higher order differences eventually reduce to a constant. This structure allows the computation of subsequent sequential values using only addition, bypassing the need for complex multiplication machinery. + The mechanical application of finite differences was famously leveraged by Charles Babbage in the design of his Difference Engine. By examining the discrete changes between consecutive outputs of a polynomial function, a person can observe that the higher-order differences eventually reduce to a constant. This structure allows the computation of subsequent sequential values using only addition, bypassing the need for complex multiplication machinery.

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

    - In order to design for indefinite extension, the Turing Machine tape must retain the function value alongside with its forward differences. Because the second difference is constant higher order differences are all zero. Hence the tape requires a three component vector to hold the differences. + In order to design for indefinite extension, the Turing Machine tape must retain the function value alongside with its forward differences. Because the second difference is constant higher-order differences are all zero. Hence the tape requires a three component vector to hold the differences.

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

    - The main diagonal contains strictly non zero factorials, ensuring the matrix is invertible. By inverting this matrix, a person replaces the cascading back substitution with a direct, closed form equation to recover any constant a_i. The inversion utilizes the signed Stirling numbers of the first kind, denoted s(n,i) (see the Appendix on Stirling numbers, section ). + The main diagonal contains strictly non-zero factorials, ensuring the matrix is invertible. By inverting this matrix, a person replaces the cascading back substitution with a direct, closed form equation to recover any constant a_i. The inversion utilizes the signed Stirling numbers of the first kind, denoted s(n,i) (see the Appendix on Stirling numbers, section ).

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

    +

    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.

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

    - Evaluating this form in the first order at the point t=5 returns a (divide 0 0). It is a strange thing, because when we plot h(t) values, against t there is an obvious correct value on the curve at t=5. There is no special feature that would make it questionable. + Evaluating this form in the first-order at the point t=5 returns a (divide 0 0). It is a strange thing, because when we plot h(t) values, against t there is an obvious correct value on the curve at t=5. There is no special feature that would make it questionable.

    - Suppose we move to a second order evaluation, and for places the computation does not work, we return the machine that isn't evaluating. That is similar to what we did to get (divide 0 0), but the zeros in that expression came from a prior step first order evaluation. Let us instead give the quotient composer two machines to compose, and have it return a value when reduction to the first order is possible, and return the full problem as posed to it when it can not be reduced. + Suppose we move to a second-order evaluation, and for places the computation does not work, we return the machine that isn't evaluating. That is similar to what we did to get (divide 0 0), but the zeros in that expression came from a prior step first-order evaluation. Let us instead give the quotient composer two machines to compose, and have it return a value when reduction to the first-order is possible, and return the full problem as posed to it when it can not be reduced.

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

    - As the second order evaluation returned (divide f(k)|k=5 g(k)|k=5), we can use L'Hôpital evaluator to resolve this indeterminate form D_{0,5}. Note this is during the creation of the D_0 vector, so it is part of the simplification step, rather than being part of the evaluation of the quotient. The result will thus be used in producing an extension machine that extends through the singularity, so the user will not see any exceptional higher order values while extending h(t). + As the second-order evaluation returned (divide f(k)|k=5 g(k)|k=5), we can use L'Hôpital evaluator to resolve this indeterminate form D_{0,5}. Note this is during the creation of the D_0 vector, so it is part of the simplification step, rather than being part of the evaluation of the quotient. The result will thus be used in producing an extension machine that extends through the singularity, so the user will not see any exceptional higher-order values while extending h(t).

    - The L'Hôpital evaluator will discover that a transcendental constant is required. It will be returned as a higher order object, a machine definition, because the value can not be written to the tape. + The L'Hôpital evaluator will discover that a transcendental constant is required. It will be returned as a higher-order object, a machine definition, because the value can not be written to the tape.

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

    -

    And for the victory lap, evaluation versus higher order computation and function extension:

    +

    And for the victory lap, evaluation versus higher-order computation and function extension:

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

    It is said to be a continuous function over the real field. However, from a computational perspective, it is a string of 8 discrete symbols. A person might ask then, "If the function is not continuous, then how can a person take a derivative?" Often people view a derivative as a tangent line to a curve drawn on a plot. The computational analyst's answer is to use a machine that manipulates the symbols; it will move the 3 down in front of the t, decrement the power, and write 2. Those are all discrete operations.

    -

    The point of this chapter is to state that computational analysis exists, rather than to present a comprehensive computational analysis system. If a person is looking for practical systems for extending functions that expand precision, or for second order computation, there are options.

    +

    The point of this chapter is to state that computational analysis exists, rather than to present a comprehensive computational analysis system. If a person is looking for practical systems for extending functions that expand precision, or for second-order computation, there are options.

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

    - The competing standard, initially backed by Intel and soon adopted as the IEEE standard, demanded accuracy to the last bit for each operation, alongside synchronized interrupts. This predictable structure permitted a program to overflow, promote the value, and seamlessly continue an operation. It also specified the use of error tags that participate in a higher order error algebra. This standard ultimately prevailed because its precision guarantees and deterministic predictability provided the necessary foundation for the formal analysis of programs. + The competing standard, initially backed by Intel and soon adopted as the IEEE standard, demanded accuracy to the last bit for each operation, alongside synchronized interrupts. This predictable structure permitted a program to overflow, promote the value, and seamlessly continue an operation. It also specified the use of error tags that participate in a higher-order error algebra. This standard ultimately prevailed because its precision guarantees and deterministic predictability provided the necessary foundation for the formal analysis of programs.

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

    - Frege's set theory is then the analysis of a logic program against an enumeration of inputs to choose if a proposed symbol is in a set. Perhaps executing such a program is left to first order analysis, or perhaps execution is not practical, and evaluation is left to second order analysis. + Frege's set theory is then the analysis of a logic program against an enumeration of inputs to choose if a proposed symbol is in a set. Perhaps executing such a program is left to first-order analysis, or perhaps execution is not practical, and evaluation is left to second-order analysis.

    - Russell's Paradox will then be expressed as a Turing Machine that can be analyzed in the second order, but cannot be analyzed in the first order. That is, the paradox exists merely in the first order as it will never halt when run. However, it is not a paradox in the second order. It is, of course, through second order analysis that we are able to describe why Russell's Set description does not resolve in the first order. + Russell's Paradox will then be expressed as a Turing Machine that can be analyzed in the second-order, but cannot be analyzed in the first-order. That is, the paradox exists merely in the first-order as it will never halt when run. However, it is not a paradox in the second-order. It is, of course, through second-order analysis that we are able to describe why Russell's Set description does not resolve in the first-order.

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

    - This brings us back to the reference from the Zermelo discussion in the introduction. Specifically, the question posed is if our finding through second order analysis that Russell's paradoxical set formulation will not run in the first order and define a set, does this mean that we are merely using S to state that we are tossing out sets that cannot be defined? The answer is it is not quite this simple. Had Frege said, 'we merely dismiss such sets', we would not have the formalization for the second order analysis. Throwing out Russell's paradox simply because we ran it and it never halted is not a practical approach. Instead, we omit it specifically from S because analyzing R reveals that it fails to define a first order halting machine, and S, by definition, only holds first order halting machines. Zermelo's language is precise and formal. However, it is this bothersome nuance, now articulated here, which caused us to scratch our heads when reading Zermelo the first time. + This brings us back to the reference from the Zermelo discussion in the introduction. Specifically, the question posed is if our finding through second-order analysis that Russell's paradoxical set formulation will not run in the first-order and define a set, does this mean that we are merely using S to state that we are tossing out sets that cannot be defined? The answer is it is not quite this simple. Had Frege said, 'we merely dismiss such sets', we would not have the formalization for the second-order analysis. Throwing out Russell's paradox simply because we ran it and it never halted is not a practical approach. Instead, we omit it specifically from S because analyzing R reveals that it fails to define a first-order halting machine, and S, by definition, only holds first-order halting machines. Zermelo's language is precise and formal. However, it is this bothersome nuance, now articulated here, which caused us to scratch our heads when reading Zermelo the first time.

    - 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?

    diff --git a/document/todo.txt b/document/todo.txt index 4674623..ffbc1fe 100644 --- a/document/todo.txt +++ b/document/todo.txt @@ -1,5 +1,8 @@ reverse the numbering of list items on the abstraction stack +The question is subscripted by machine: a_{i,k} = q_{i,k}(m_i, {x_{i,j}}). But the inconsequential condition is ∀k: a_{i,k} = a_{i.1,k}, which requires the same question asked of both machines — and q_{i,k} and q_{i.1,k} are, on your own indexing, different questions. The definition silently assumes they are the same. Dropping the machine subscript, so a_{i,k} = q_k(m_i, {x_{i,j}}), would make it airtight, since a question in computation theory is asked of any machine rather than belonging to one. Your formalism, your call — but this is the definition the whole book leans on, and it's the sort of thing a referee finds. + +Related and smaller: computation theory C is introduced and then never used again. 2026-03-26 03:41:44