From: Thomas Walker Lynch Date: Mon, 27 Jul 2026 08:25:57 +0000 (+0000) Subject: machine revision comming along X-Git-Url: https://git.reasoningtechnology.com/%27%20%20%20window.RT.dirpr_library%20%20%20%27/Hindu-Arabic%20number%20fig%201.png?a=commitdiff_plain;h=a1e0269e87d6fb58359ebaf98aedaecf67851045;p=TM-2026 machine revision comming along --- diff --git a/document/book/TM-2026.html b/document/book/TM-2026.html index 538842a..77d8bc9 100644 --- a/document/book/TM-2026.html +++ b/document/book/TM-2026.html @@ -39,7 +39,7 @@

At a conference in Paris in 1900, David Hilbert presented a list of pressing unsolved problems in mathematics. - Second on his list was "The Compatibility of the Arithmetical Axioms." Hilbert challenged mathematicians to find a means to demonstrate that "a finite number of logical steps based upon them [axioms] can never lead to contradictory results" F. N. Cole et al., eds., Bulletin of the American Mathematical Society, Vol. 8 (New York: Macmillan, 1902). This can be found at https://www.gutenberg.org/cache/epub/71655/pg71655 images.html. The MathWorld article on this subject, https://mathworld.wolfram.com/HilbertsProblems.html, explains that Hilbert presented 10 problems at the conference, though the publication shows 23 problems, and shortly later a 24th problem was added. Based on the notes of this citation, it appears the second problem is the same on all of these lists. Also note, Hilbert discusses completeness specifically as an axiom for bounding on the sets, which appears to be distinct from the question of logical completeness for an axiomatic system.. + Second on his list was "The Compatibility of the Arithmetical Axioms." Hilbert challenged mathematicians to find a means to demonstrate that "a finite number of logical steps based upon them [axioms] can never lead to contradictory results" F. N. Cole et al., eds., Bulletin of the American Mathematical Society, Vol. 8 (New York: Macmillan, 1902). This can be found at https://www.gutenberg.org/cache/epub/71655/pg71655-images.html. The MathWorld article on this subject, https://mathworld.wolfram.com/HilbertsProblems.html, explains that Hilbert presented 10 problems at the conference, though the publication shows 23 problems, and shortly later a 24th problem was added. Based on the notes of this citation, it appears the second problem is the same on all of these lists. Also note, Hilbert discusses completeness specifically as an axiom for bounding on the sets, which appears to be distinct from the question of logical completeness for an axiomatic system..

@@ -111,7 +111,7 @@ The Turing Machine transforms mathematics into computing

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

@@ -167,12 +167,12 @@

- An architecture provides programmers with information that is valuable when designing the logic of programs. This includes programmers across the entire software stack, such as firmware engineers, driver developers, systems programmers, compiler writers, and application developers. Although applications programs might only be exposed to the virtual architecture presented by various standards, various libraries, and the programming language used. In addition to specifying the instructions (instruction set architecture), architecture includes describing the memory and hardware virtualization features, specifying the behavior of the interrupt subsystem, the method of doing I/O, DMA, the special registers and their effects, any architectural busses, and the standards to be followed for each if any. More recently, this also includes specifying how programs can make use of secure areas. The architecture is specified by an architect. + An architecture provides programmers with information that is valuable when designing the logic of programs. This includes programmers across the entire software stack, such as firmware engineers, driver developers, systems programmers, compiler writers, and application developers. Although applications programs might only be exposed to the virtual architecture presented by various standards, various libraries, and the programming language used. In addition to specifying the instructions (instruction set architecture), architecture includes describing the memory and hardware virtualization features, specifying the behavior of the interrupt subsystem, the method of doing I/O, DMA, the special registers and their effects, any architectural busses, and the standards to be followed for each if any. More recently, this also includes specifying how programs can make use of secure areas. The architecture is specified by an architect.

The classic text by Hamacher, Vranesic, and Zaky carefully defines the organizational level as sitting between architecture and implementation V. Carl Hamacher, Zvonko G. Vranesic, and Safwat G. Zaky, Computer Organization, 5th ed. (New York: McGraw Hill, 2002).. - Organization is the register transfer level description of the machine, which includes internal buses, external buses and the state machines that implement the protocols used, control units, interrupt structures, and ALU layout. Crucially, it is at this level that decisions regarding instruction level parallelism are made, such as whether the processor will employ a scalar, superscalar, or VLIW design, the depth of its execution pipelines, the use of out of order execution, branch prediction strategies, and the specific hierarchy of hardware caches. It dictates the logical arrangement of hardware and the procedures that force the data to flow to satisfy the architectural constraints. Organization is sometimes called micro architecture, and it is made by a design architect. + Organization is the register transfer level description of the machine, which includes internal buses, external buses and the state machines that implement the protocols used, control units, interrupt structures, and ALU layout. Crucially, it is at this level that decisions regarding instruction level parallelism are made, such as whether the processor will employ a scalar, superscalar, or VLIW design, the depth of its execution pipelines, the use of out of order execution, branch prediction strategies, and the specific hierarchy of hardware caches. It dictates the logical arrangement of hardware and the procedures that force the data to flow to satisfy the architectural constraints. Organization is sometimes called micro architecture, and it is made by a design architect.

@@ -180,11 +180,11 @@

- The implementation instructs the manufacturing teams very specifically on what is to be built. For a microprocessor chip, this consists of the full wiring of the logic gates and transistors, instructions for cutting the lithography masks, the package to be used, and the production test programs to be run. The instructions for cutting the masks consist of the sizes and placement of doping wells and gates, the placement of contacts, and where to run wires. The implementation is designed by design engineers, with the assistance of design synthesis tools and CAD tools. + The implementation instructs the manufacturing teams very specifically on what is to be built. For a microprocessor chip, this consists of the full wiring of the logic gates and transistors, instructions for cutting the lithography masks, the package to be used, and the production test programs to be run. The instructions for cutting the masks consist of the sizes and placement of doping wells and gates, the placement of contacts, and where to run wires. The implementation is designed by design engineers, with the assistance of design synthesis tools and CAD tools.

- A realization is a physical box full of plastic, metal, fiberglass, and silicon, along with a smattering of exotic materials. A realization is made by manufacturing engineers, technicians, and product line workers, with the assistance of some of the most sophisticated machines ever built by humankind. + A realization is a physical box full of plastic, metal, fiberglass, and silicon, along with a smattering of exotic materials. A realization is made by manufacturing engineers, technicians, and product line workers, with the assistance of some of the most sophisticated machines ever built by humankind.

@@ -226,7 +226,7 @@

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

Definition of the same results transform property

@@ -264,7 +264,7 @@

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

@@ -322,7 +322,7 @@

- then T is computation theoretic inconsequential for m_i. + then T is computation theoretic inconsequential for m_i.

@@ -334,7 +334,7 @@

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

The computation theoretic Turing Machine @@ -617,7 +617,7 @@

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. If the computational Turing Machine's empty symbol maps to a word of zeros, then the empty symbol remains a poor model, because generally the data message, say sent between the input writer and the recognizer receiver, will also contain many zeros. The advantage is that if a programmer attempts to dereference a zero pointer, a segmentation fault occurs. So in this system, the programmer is again burdened with maintaining the "read only after write" rule.

+

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. For pointers the zero pointer is an a sense an empty symbol, and 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 will attempt to help with this by throwing errors upon the use of uninitialized data that they detect.

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

@@ -632,93 +632,89 @@

An example of effectively unspecified data would be a program that reverses a string without looking at the values being reversed. A string reverse function need not inspect the value of the string; it only needs to recognize the structural boundaries established by the writing protocol. Yet the conventional Turing Machine is incapable of doing this, and worse, as we saw, there is a proportional increase in the number of states for the reverse string controller when the number of symbols, symbols that could have been ignored for control purposes, is expanded.

-

The computation theoretic TTCA Machine

+

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

-

A goal of the computation theorist in defining a Turing Machine is to make the math concise and elegant. However, the goal of the computer architect is to define a machine that is intuitive to design and test, and that performs well. Perhaps if a computer architect were to define the computation theoretic Turing Machine, this change in emphasis would favor a different definition.

+

The computation theoretic TTCA Machine

-

The following modifications will be made to the computation theoretic Turing Machine definition so as to support the unspecified symbol:

+

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

+ +

The specific architectural modifications are as follows:

    -
  1. Move to a Moore style programmed state controller, so that actions can be managed separately from state transitions.
    2. -
  2. Introduce explicit actions for reading: a state transition gating read (read_g) and a data read (read_d), which target their respective dedicated registers. Additionally, provide a status action that also targets the g register.
    3. -
  3. To match the read functions, the write actions can specify writing a constant symbol (write_σ), or the contents of either the data or gate register (write_d, write_g).
    4. -
  4. If the unspecified symbol is read into the state transition gating register, the machine transitions to the predefined unspecified_decision state.
    5. +
  5. There is one unified alphabet \Sigma to which both status symbols and data symbols belong.
    6. +
  6. It utilizes a Moore-style programmed state controller, so that actions can be managed separately from state transitions.
    7. +
  7. It separates control flow from data flow: +
      +
    1. Two registers exist within the machine: one for holding a symbol upon which control decisions are made, the s (status) register; and one for holding data upon which decisions are not based, the d (data) register. Here, s stands for 'status', as its value is a condition flag utilized by the programmed controller when determining the next state, while d stands for 'data'.
      2. +
    2. Read and write actions accept an operand designating the target or source register respectively, either s or d.
      3. +
    +
    8. +
  8. It implements default state transitions that execute when no explicit transition is given in the main state transition table of triples (each triple being \langle S_i, \sigma, S_{i+1} \rangle): +
      +
    1. state-specific transition default pairs, which have the form \langle S_i, S_{i+1} \rangle
      2. +
    2. status-specific transition default pairs, which have the form \langle \sigma, S_{i+1} \rangle
      3. +
    3. a global default transition, which has the form S_{i+1}
      4. +
    +
-

For ease of programming, the new machine evaluates next-state transitions through a four-layer hierarchy:

+

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:

    -
  1. Fixed global default (δF_0): Selects the rule that matches the value in the gate register. There is only one rule in this set; it compares the gate register to the unspecified symbol, then transitions to the unspecified_decision state.
    2. -
  2. Programmed Conditional (δ_1): Selects the transition rule that matches the current state and the value of the gate register.
    3. -
  3. Programmed Default (δ_2): If no conditional next state rule is found, selects the default transition rule that matches the current state.
    4. -
  4. Global Fallback (δ_3): An unconditional transition of last resort if no prior layer provides a valid next state.
    5. +
  5. Conditional (\delta_0): Selects the transition rule that matches the current state and the value of the status register.
    6. +
  6. State Default (\delta_1): If no conditional next state rule is found, selects the default transition rule that matches the current state.
    7. +
  7. Status Default (\delta_2): If no next state rule has been found, selects the default transition rule that matches the current machine status.
    8. +
  8. Global Default (\delta_3): An unconditional transition of last resort if no prior layer provides a valid next state.
+ +

Programmers will typically use the Global Default arc, \delta_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.

-

For clarity of presentation, the definition will be partitioned according to 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.

+

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 \Sigma, adding a Q_unspecified state to Q, and then adding a status default arc to \delta_2 of \langle \mathtt{unspecified}, \mathrm{Q\_unspecified} \rangle. Then, if the machine attempts to make a decision upon the unspecified symbol, the machine will go to the Q_unspecified state. Such a machine can then be analyzed to see if it ever visits the Q_unspecified state.

+ +

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 action, 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 affects the multiplier constant on the linear term of the step count formula but does not change the computation complexity class determined from such a step count. The layers of next-state functions can be collapsed into one layer, where the missing arguments are filled in with all possible unused values. This potentially increases the number of state transition arcs that must be specified, but the state transition logic and the number of states remain unchanged. Partitioning the machine definition by separation of concerns does not change the total specification. Hence, these modifications are computation theoretic inconsequential.

The TTCA Machine fixed part

- - MF = (QF, ΣF, AF, δF_0, HF) - + \mathrm{MF} = (\mathrm{QF}, \mathrm{\Sigma F}, \mathrm{AF})
-

In the following the middle dot acts as a namespace operator, N{·}x. By doing this we assure there will be no aliasing with the symbols provided by the programmer when he defines the programmed state controller.

+

In the following, the middle dot acts as a namespace operator, N{\cdot}x. By doing this we assure there will be no aliasing with the symbols provided by the programmer when defining the programmed state controller.

The set of predefined states:

- QF = \{QF{·}\mathtt{initial}, QF{·}\mathtt{unspecified\_decision}\} + \mathrm{QF} = \{\mathrm{QF}{\cdot}\mathtt{initial}\}
-

The state controller always starts in the QF·initial state. This is a symbol representing the state, it is not a register that holds a state. The 'F' values are all fixed.

- -

If a decision is attempted to be made on an ΣF·unspecified symbol, the machine transitions to the QF·unspecified_decision state, due to the global default transition defined in δF_0.

+

The state controller always starts in the QF·initial state. This is a symbol representing the state; it is not a register that holds a state. The 'F' values are all fixed.

-

The set of available actions:

+

The programmer cannot add actions to the machine definition, so there are only fixed actions:

\begin{aligned} - AF = \{\\ + \mathrm{AF} = \{& \\ & \mathtt{no\_op} \\ , & \mathtt{left} \\ , & \mathtt{right} \\ - , & \mathtt{read\_d} \\ - , & \mathtt{read\_g} \\ + , & \mathtt{read}(\mathtt{d} \mid \mathtt{s}) \\ , & \mathtt{status} \\ - , & \mathtt{write\_σ}(σ) \\ - , & \mathtt{write\_d} \\ - , & \mathtt{write\_g} \\ + , & \mathtt{write}(\mathtt{d} \mid \mathtt{s} \mid \mathtt{\sigma}, [\sigma]) \\ \} \end{aligned}
-

where σ must be in Σ.

+

where \sigma must be in \Sigma.

The set of predefined symbols:

- ΣF = \{ΣF{·}\mathtt{unspecified}, ΣF{·}\mathtt{on\_leftmost}\} -
- -

The set δF_0 holds one global default predefined transition of the form, -

- - \{\langle \mathtt{g{.}ΣF{·}unspecified}, \mathtt{QF{·}unspecified\_decision} \rangle\} - -
- -

In any state if the g register holds the symbol \mathtt{ΣF{·}unspecified}, then the next state will be \mathtt{QF{·}unspecified\_decision}, independent of all other defined next state transitions.

- -

The set of predefined halting states (only one):

-
- HF = \{QF{·}\mathtt{unspecified\_decision}\} + \mathrm{\Sigma F} = \{\mathrm{\Sigma F}{\cdot}\mathtt{on\_leftmost}\}

The TTCA Machine variables

- MV = (q, d, g) + \mathrm{MV} = (q, d, s)
@@ -726,55 +722,60 @@

d: is the data register.

-

g: is the gate register.

+

s: is the status register.

The TTCA Machine programmable part

- MP = (QP, ΣP, λP, δ_1, δ_2, δ_3, HP) + \mathrm{MP} = (\mathrm{QP}, \mathrm{\Sigma P}, \lambda\mathrm{P}, \delta_0, \delta_1, \delta_2, \delta_3, \mathrm{HP})

A set of programmed state symbols:

- QP + \mathrm{QP}

A set of programmed data symbols:

- ΣP + \mathrm{\Sigma P}

The programmed actions. A set of pairs of the form:

- λP = \{ \langle q_0, a \rangle, \dots \} + \lambda\mathrm{P} = \{ \langle q_0, a \rangle, \dots \}
-

where q_0 is matched to the current state, and a is a member of AF.

+

where q_0 is matched to the current state, and a is a member of \mathrm{AF}.

-

A set of state transition triples; each triple is of the form:

+

The conditional transition table. A set of state transition triples; each triple is of the form:

- δ_1 = \{ \langle q_0, r{·}σ, q_1 \rangle, \dots \} + \delta_0 = \{ \langle q_0, r{\cdot}\sigma, q_1 \rangle, \dots \}
-

where q_0 is matched to the current state of the machine. r{·}σ is a symbol in register r, where r is either d or g. q_1 is the next state. When q_0 matches the current state, q_1 becomes the next state. Both q_0 and q_1 come from the total set Q. σ comes from the total set Σ.

+

where q_0 is matched to the current state of the machine. r{\cdot}\sigma is a symbol in register r, where r is either d or s. q_1 is the next state. When q_0 matches the current state and the specified register holds \sigma, q_1 becomes the next state. Both q_0 and q_1 come from the total set Q. \sigma comes from the total set \Sigma.

-

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

+

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

- δ_2 = \{ \langle q_0, q_1 \rangle, \dots \} + \delta_1 = \{ \langle q_0, q_1 \rangle, \dots \}

where q_0 is matched to the current state, and upon a match q_1 will be taken as the next state.

-

A default next state:

+

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

- δ_3 = q_1 + \delta_2 = \{ \langle r{\cdot}\sigma, q_1 \rangle, \dots \}
+

where r{\cdot}\sigma matches the symbol in register r (either d or s), and upon a match q_1 will be taken as the next state.

-

This is the transition of last resort. It is unconditional, the next state becomes q_1.

+

The global default next state:

+
+ \delta_3 = q_1 +
+

This is the transition of last resort. It is unconditional; the next state becomes q_1.

-

A set of programmer defined halting states:

+

A set of programmer-defined halting states:

- HP + \mathrm{HP}
@@ -782,31 +783,30 @@
- M = (Q, Σ, AF, λP, δ, H) + M = (Q, \Sigma, \mathrm{AF}, \lambda\mathrm{P}, \delta, H)

The complete set of states, uniting the fixed predefined states and the programmed states:

- Q = QF \cup QP + Q = \mathrm{QF} \cup \mathrm{QP}

The complete set of symbols, uniting the fixed control symbols and the programmed data symbols:

- Σ = ΣF \cup ΣP + \Sigma = \mathrm{\Sigma F} \cup \mathrm{\Sigma P}

The ordered sequence of next state transition rules:

- δ = [δF_0 | δ_1 | δ_2 | δ_3] + \delta = [\delta_0 \mid \delta_1 \mid \delta_2 \mid \delta_3]

The complete set of halting states, uniting the fixed predefined states and the programmed states:

- H = HF \cup HP + H = \mathrm{HF} \cup \mathrm{HP}
-

Computation theoretic TTCA Machine executor

To execute the programmed TTCA Machine, a person must maintain the current machine variables MV and evaluate the programmed logic in an repeating two-phase cycle, until a halting state is reached. Because this is a Moore-style architecture, the execution of an action is isolated from the evaluation of the next state transition.

@@ -848,8 +848,11 @@ # TTCA Machine String Reverse - # input: (σ ∈ Σ)* EOM (starting on the leftmost cell) - # output: SP* EOM (σ ∈ Σ in reverse)* EOR + # Domains: + # ΣP = {0, 1, EOM, EOR, SP} + # Σ_data = ΣP \ {EOM, EOR, SP} + # input: (σ ∈ Σ_data)* EOM (starting on the leftmost cell) + # output: SP* EOM (σ ∈ Σ_data in reverse)* EOR halt: Q·Done @@ -1247,7 +1250,7 @@

Suppose a controller is not analyzed to determine its computation theoretic complexity, or even tested against worst-case inputs, but is instead run with random or everyday input to gather performance measurements. This process is called profiling. After many runs, a programmer might surmise the behavioral limits of the program. However, many programs are neither linear systems nor smooth functions. With a different set of inputs than those used for profiling, perhaps even values adjacent to prior inputs, the program behavior can shift drastically. Consider the Pentium divider. It did not matter how many millions of times the result was accurate; the fact remains that customers later found an input that yielded wildly inaccurate results. Only by elevating the analysis to the structural logic of the code can such an eventuality from an erroneous program be categorically ruled out. This is why the K5 transcendental function development project included a proof writing phase; see Thomas Walker Lynch, A. Ahmed, M. Schulte, T. Callaway, and R. Tisdale, "The K5 Transcendental Functions," Proceedings of the 12th IEEE Symposium on Computer Arithmetic, 1995. DOI: 10.1109/ARITH.1995.465368.

-

Head unit, HU

+

Head Unit, HU

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

@@ -1257,9 +1260,7 @@
  • status → γ
    • -

    One or more head units are plugged into the TTU, which is described in the next section. The TTU only sends commands when a tape is mounted.

    - -

    On this model of machine, the HU status is identical to the cell type. The cell type does not come from the tape, so the HU must work in conjunction with the TTU to derive its value. In review the cell types are:

    +

    On this model of machine, the HU status is identical to the indicated cell's type. The cell type is not read from the tape; rather, it is derived from the head's physical relationship to the ends of the tape. Consequently, the HU works in conjunction with the TTU to derive the status. (The tape transport unit, the TTU, is discussed in the next section.) As established in the section discussing cells, cell types are:

    1. leftmost
      2. @@ -1268,9 +1269,11 @@
    2. island
    -

    A status of rightmost or island would never be returned for a computation theoretic Turing Machine tape. This is where having a finite extendable tape can differ from that of a single ended theoretical object.

    - -

    Each HU has a data buffer that can be read or written, and a status buffer that can be read.

    +

    A computation theoretic Turing Machine would never encounter a status of rightmost or island. This is where a finite extendable tape structurally differs from a single-ended theoretical tape.

    + +

    For a realized TTU, data can only be read or written when there is relative motion between the head and the tape. Consequently, in an HU implementation, data and status registers are updated from an internal buffer that acquires data during head motion. Conversely, a write value is buffered until subsequent head motion provides the opportunity to write it to the tape.

    + +

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

    Tape transport unit, TTU

    @@ -1442,8 +1445,6 @@

    Description of a read_g command

    -

    A magnetic tape head reads when the tape is moving, so ironically it is like the Emacs cursor. The read will occur when the machine steps, and the data will be waiting in the data buffer for a read command. The head will wait at the other side of the cell. Unlike the theoretical tape, there is interstitial space between the cells where the head can wait for the next command, then swipe further right. In a real machine, blocks of cells will always be read, and the buffer will be much deeper.

    -

    The current state latch, q, is open on the falling edge of the clock, and then samples and holds while the clock is high. The gate register, g, is the phase inverse; it is open while the clock is high, and samples and holds while the clock is low.

    On the rising edge of the clock, the state is latched. The current state signal ripples through the Action Table. As the q register is stored as a one-hot value, this happens very quickly. Rather than placing commands in the Action Table, the decoded values of the commands that are needed for control are programmed directly into the table. Among the decoded outputs of the action command is a control signal that enables the opening of the gate register latch.

    @@ -1489,7 +1490,7 @@

    - Given an original, all copies stemming from it will be equal to each other and to the original. By stemming from, this definition includes all direct copies and copies of copies. + Given an original, all copies stemming from it will be equal to each other and to the original. By stemming from, this definition includes all direct copies and copies of copies.

    @@ -4216,6 +4217,6 @@ Now suppose defining a Turing Machine that initially has the head on the leftmos --> -->