From: Thomas Walker Lynch Date: Tue, 14 Jul 2026 17:10:35 +0000 (+0000) Subject: . X-Git-Url: https://git.reasoningtechnology.com/%5B%5E?a=commitdiff_plain;h=89a6308401650160d04199fa8289717e0253039d;p=TM-2026 . --- diff --git a/document/Boolos.txt b/document/Boolos.txt deleted file mode 100644 index 69df079..0000000 --- a/document/Boolos.txt +++ /dev/null @@ -1,31 +0,0 @@ -The Mechanics of Boolos's Proof -Boolos formalized the Berry Paradox to prove Gödel's Incompleteness without utilizing Cantor's diagonal array or heavy Gödel numbering. Here is the step-by-step logical sequence: - -1. Definability via WFFs -Within any formal mathematical system, we form WFFs using a strict, finite alphabet. A WFF with exactly one free variable, say F(x), "defines" or "names" a specific Natural Number k if the system can definitively prove F(k) is true, and rigorously proves F(y) is false for any y - -=k. - -2. The Physical Limit of Naming -Because the system's alphabet is finite, the total count of valid WFFs containing fewer than N symbols is absolutely finite. Since each WFF can name at most one distinct Natural Number, the total set of numbers definable by fewer than N symbols is also completely finite. - -3. The Inevitable Exception -The set of Natural Numbers is unbounded. Therefore, there absolutely must exist Natural Numbers that require WFFs longer than N symbols to define them. Consequently, by the well-ordering principle of Natural Numbers, there must exist a singular, smallest such number. - -4. The Mechanical Contradiction -Boolos demonstrated that an analyst can form a specific WFF within the formal system, let us call it B(x), which translates logically to the following constraint: - -x is the smallest Natural Number not definable by a formula containing fewer than 10,000 symbols. - -5. The Resolution (Incompleteness) -The formula B(x) itself contains far fewer than 10,000 symbols when written out in the formal alphabet. - -If the axiomatic system is perfectly complete, it must be able to prove B(k) for the actual, correct number k. But doing so results in an immediate paradox. The system would use a short WFF to definitively name a number that the very same WFF asserts cannot be named by a short WFF. - -To remain mathematically consistent, the system simply cannot prove B(k). The exception exists—there genuinely is a smallest unnameable number—but the formal system is too mechanically limited to prove which number it is. - -Integration into the TTCA Book -This proof completely bypasses the unearned assumptions of actual infinity and infinite diagonal sequences. It rests entirely on the finite, physical limitations of alphabets and the finite length of WFFs. - -Since this proof relies so heavily on the mechanical limits of the alphabet, how do you plan to introduce the concept of "definability" to the reader before presenting this paradox in the appendix? - diff --git a/document/D_10.png b/document/D_10.png deleted file mode 100644 index d7c8887..0000000 Binary files a/document/D_10.png and /dev/null differ diff --git a/document/RT-Manuscript_locator.js b/document/RT-Manuscript_locator.js deleted file mode 100644 index e5ad4f5..0000000 --- a/document/RT-Manuscript_locator.js +++ /dev/null @@ -1,51 +0,0 @@ -/* - indirect.js - - We have four scenarios - - immediate - used in the RT-Style distribution itself (authored, consumer, staged) - direct - used in the RT-Style project itself, but not in the distribution - indirect - the version all Harmony projects use - URL-only - always pulls style through a URL, a webserver must be present - -*/ - -window.RT = window.RT || {}; - -// --- Configuration --- -// Define the consumer project name to allow dynamic local file:// calculation. -window.RT.project_name = "TM-2026"; - -// Fallback URL when served over a network where the project root is not in the URI. -window.RT.server_url = "http://localhost:8000/shared/linked-project/RT-Style/Manuscript"; - -(function() { - let style_path = window.RT.server_url; - - if (window.RT.project_name) { - const path = window.location.pathname; - const project_root_index = path.indexOf('/' + window.RT.project_name + '/'); - - if (project_root_index !== -1) { - // substring(0, stop) extracts up to the project name, leaving off the trailing slash. - // We append the explicit forward slash before navigating into the shared boundary. - const absolute_project_root = path.substring(0, project_root_index + window.RT.project_name.length + 1); - - // The symlink 'RT-Style' already drops us inside the 'consumer/' directory, - // so we proceed directly to 'Manuscript'. - style_path = absolute_project_root + "/shared/linked-project/RT-Style/Manuscript"; - } else { - console.warn("RT-Style: Cannot locate project root '/" + window.RT.project_name + "/' in URI. Falling back to server_url."); - } - } - - window.RT.dirpr_library = style_path; - - document.write( - ' - - - - - - - - - - - The search that led to the Turing Machine - -

- In 1893 Gottlob Frege published an axiomatic construction of mathematics from set theory. Frege's grand objective was something he called Logicism, the philosophical thesis that all of mathematics can be derived entirely from pure logic. To bridge set theory and logic, Frege defined sets using a method known as set comprehension. Under this approach, a mathematician states a logical rule or property, and any object satisfying that logical statement automatically becomes a member of the set. Because the membership of a set is determined entirely by logical rules, the resulting sets, and the mathematics built upon them, are derived directly from logic. To implement this, his specific machinery relied upon unrestricted set comprehension, formalized as Basic Law V Gottlob Frege, Grundgesetze der Arithmetik, Vol. 2 (Jena: Hermann Pohle, 1903), Appendix (Nachwort), 253.. -

- -

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

- -

- In 1901 Bertrand Russell found a well formed set formulation using Frege's set theory that did not correspond to a set. As Frege's work was based on this set theory, this called into question his entire work. Russell pointed out that it was possible to define a set of all sets that do not contain themselves. However this was a paradox, because if said set contained itself, it shouldn't, and if it didn't it should. Thus the formulation failed to define a set because the logical condition cannot be satisfied Bertrand Russell, The Principles of Mathematics (Cambridge: Cambridge University Press, 1903), Chapter X, 'The Contradiction'.. Russell communicated this to Frege in a letter dated 1902 06 16, shortly before his second volume was going to print Bertrand Russell to Gottlob Frege, June 16, 1902, reprinted in Jean van Heijenoort, From Frege to Gödel: A Source Book in Mathematical Logic (Cambridge: Harvard University Press, 1967), 124 125. Gottlob Frege, Grundgesetze der Arithmetik, Vol. 2 (Jena: Hermann Pohle, 1903), Appendix (Nachwort), 253. Frege writes: 'Hardly anything more unfortunate can befall a scientific writer than to have one of the foundations of his edifice shaken after the work is finished.'. Frege hurriedly authored an appendix (the Nachwort) admitting his system was compromised Frege was a quiet, rigid man who had spent decades building his logical fortress in almost total academic obscurity. Frege was personally devastated by Russell's letter. Shortly after, he suffered the loss of his wife, fell into severe depression, and his academic output almost entirely ceased. In 1924, a year before his death, he wrote unpublished diaries explicitly surrendering his life's work, declaring that logicism was a mistake and that mathematics must actually be derived from geometry. Note I. Grattan Guinness, The Search for Mathematical Roots, 1870 1940 (Princeton: Princeton University Press, 2000). For an analysis of Frege's intellectual decline, personal tragedies, and his unpublished 1924 1925 diaries where he formally surrenders the logicist program, see Chapter 7.. -

- -

- In 1903 Russell proposed a hierarchy of types to repair this foundational vulnerability. At the base were sets of individuals, then sets based on individuals or sets of individuals, etc. This looks a lot like how types work in modern software Bertrand Russell, The Principles of Mathematics (Cambridge: Cambridge University Press, 1903), Appendix B: The Doctrine of Types.. In this manner, it is not possible to write a paradoxical set definition. Russell and Alfred North Whitehead then engineered an entirely new, massive scaffolding utilizing this type system to pursue Frege's original objective of deriving mathematics from logic, publishing their results in three volumes between 1910 and 1913 Alfred North Whitehead and Bertrand Russell, Principia Mathematica (Cambridge: Cambridge University Press, 1910 1913).. Russell's system can be cumbersome due to requiring a large construction to be assembled in place of what otherwise might have been a simple rule. -

- -

- In 1908 Ernst Zermelo published an alternative system designed to avoid the known paradoxical statements of the time, even though absolute consistency remained unproven. In Zermelo's set theory, a mathematician first starts with an existing set, and then applies the Axiom of Separation using definite properties to partition out subsets Ernst Zermelo, "Untersuchungen über die Grundlagen der Mengenlehre I," Mathematische Annalen 65 (1908): 261 281.. To see how this works, consider the expression \{x \mid P(x)\}. Under unrestricted comprehension, a logician is permitted to define the predicate P(x) as x \notin x. This produces Russell's Paradox, so the set fails to be defined. In contrast, consider the same predicate, though restricted by Zermelo's Axiom of Separation over a predefined set S, written as \dot{R} = \{x \mid x \in S \wedge x \notin x\}. The only thing a person needs to know about S here is that it has already been successfully defined. So let us ask, is \dot{R} in \dot{R}? If we assume \dot{R} is a member of S, evaluating the second term forces the familiar fatal loop: if \dot{R} is in \dot{R}, it shouldn't be, and if it isn't, it should be. Thus if we assume that \dot{R} is in S, then \dot{R} can not be defined, but by definition, S is defined, and thus its members are defined. As we arrived at a contradiction, the original assumption must be false, i.e. it is wrong to assume that \dot{R} is in S. As \dot{R} is definitively not a member of \dot{R}, the first term of the set comprehension rule, x \in S is false, and the paradox vanishes. -

- -

- A person might suggest defining S as the set of all definable mathematical objects, forming a universal set. However, if such a universal set S existed, the Axiom of Separation could be applied using the previous predicate to isolate \dot{R}. Because \dot{R} is a valid, definable set, it must reside within S by the very definition of a universal set. But notice that the logic evaluated earlier proved definitively that \dot{R} cannot be a member of S. Yet the existence of a definable set \dot{R} that sits strictly outside of S contradicts the premise that S contains everything. Therefore, within any system governed by the Axiom of Separation, a universal set cannot exist. -

- -

- The authority to remove the Russell's Paradox set formulation comes from the set S. If we know its definition, then the authority comes through that definition. However, if we merely stipulate that S must be defined, then we are expressing our authority through S by declaring, "Undefined sets are not allowed." In the explanation above, it is only after discovering a set is undefined that we conclude it is not a member of S. I sometimes wonder how mathematics might have evolved had Frege simply taken that approach. We take this question up again in the chapter Computational Naturalism, and discover there is a deeper issue. -

- -

- Stepping back from the mechanics of set definition, a person can observe two competing approaches to establishing mathematical foundations. The first approach is constructive, building complex systems by assembling them upward from fundamental primitives. The second approach relies on islands of meaning, carving out valid spaces from the abstract void using precise rules and axioms, exactly as Zermelo did. Because both methodologies rely entirely upon a rigorous framework of deduction to function, logic itself serves as the essential substrate. Consequently, a complete foundational study requires the examination of three distinct subjects: the primitives used for construction, the rules that bound the theoretical islands, and the underlying logic that evaluates them both. -

- -

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

- -

- In 1931 Kurt Gödel published his incompleteness theorems Kurt Gödel, "Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I," Monatshefte für Mathematik und Physik 38 (1931): 173 198.. By mapping formal logic into arithmetic, he demonstrated that any consistent formal system sufficiently powerful to perform basic arithmetic, let us call it system S, will inevitably contain well formed formulas that are mathematically true yet cannot be proven within the system itself For the definitive English translation, see Jean van Heijenoort, From Frege to Gödel: A Source Book in Mathematical Logic, 1879 1931 (Cambridge: Harvard University Press, 1967), 596 616.. Gödel achieved this by engineering a specific formula that evaluates to the claim: "G: There exists no sequence of valid logical steps within system S that proves G." If system S is consistent, it cannot output a proof for G; thus, the claim G makes is factually accurate, rendering it true but mechanically unprovable. Furthermore, Gödel demonstrated that system S cannot output a proof of its own consistency. This result fractured David Hilbert's 1900 vision of utilizing a weaker, strictly "finitistic" logical subsystem to definitively prove that the axioms of arithmetic are entirely free of contradictions David Hilbert, "Mathematical Problems," Bulletin of the American Mathematical Society 8 (1902): 437 479.. If the full, powerful system S physically lacks the mechanical capacity to verify its own consistency, Hilbert's weaker finitistic subsystem is definitively incapable of accomplishing the task. Gödel's work established a hard mechanical boundary, asserting that truth and provability are distinct concepts in classical mathematics. -

- -

- In April 1936, Alonzo Church leveraged Gödel's foundational papers to directly answer the Entscheidungsproblem Alonzo Church, "An Unsolvable Problem of Elementary Number Theory," American Journal of Mathematics 58, no. 2 (April 1936): 345 363.. Working independently, Alan Turing had arrived at his own mechanical solution, and upon seeing Church's April publication, Turing rushed to submit his manuscript on 28 May 1936, appending a proof that his mechanical architecture was mathematically equivalent to Church's lambda calculus Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265. Received May 28, 1936, published November 30, 1936.. As Hilbert and Ackermann concede in the 1938 second edition of their textbook, Church's results demonstrated that "the quest for a general solution of the decision problem must be regarded as hopeless" David Hilbert and Wilhelm Ackermann, Principles of Mathematical Logic, 2nd ed. (New York: Chelsea Publishing Company, 1950), 124.. By giving the "somewhat vague intuitive concept of recursion a certain precise formalization," Church proved the "non existence of such a recursive procedure" that could mechanically yield a value of truth or falsehood for every individual formula Ibid., 124.. -

- - -

- 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 'studied' program will halt when it is run Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265.. An answer to this halting problem (specifically asserting "The studied machine halts" or "The studied 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. -

- - -

- Turing employed an enumerative diagonal argument to establish this result. A simpler proof by contradiction that is commonly used today was first published by Christopher Strachey in 1965 Christopher Strachey, "An Impossible Program," The Computer Journal 7, no. 4 (January 1965): 313. In his letter, Strachey explicitly attributed the distilled logic to an existing "well known piece of folklore among programmers.". To begin the proof, assume a person builds a perfect decider program, H(p, i), that evaluates any given program p executing with input i, then outputs 'Y' if p(i) halts, and 'N' if it does not halt. Next, a person writes a malicious program, M(x), that incorporates H as a subroutine. When M receives an input program x, it evaluates H(x, x) to determine how program x behaves when given itself as input. If H(x, x) outputs 'Y', M enters an infinite loop; if H(x, x) outputs 'N', M immediately halts. -

- - - M(x){ - if(H(x ,x) == 'Y') while(true); - else if(H(x ,x) == 'N') return; - } - - -

- The evil part occurs when we give program M(x) itself as input, M(M). Program M calls its subroutine and asks H(M, M) what M will do. If H outputs 'Y', it is wrong, because M loops infinitely. If H outputs 'N', then it is wrong, because M halts. The decider H is forced into an inescapable failure, proving that no universal decider can exist. -

- -

- While Gödel, Church, and Turing established the primary boundaries of computation, they did not work in a vacuum. During this period, the broader academic community worked to synthesize the definitive mechanics of effective calculability. Jacques Herbrand and Gödel formalized general recursive functions between 1931 and 1934 Kurt Gödel, "On Undecidable Propositions of Formal Mathematical Systems," mimeographed lecture notes, Institute for Advanced Study, Princeton, 1934.. Emil Post independently defined "Finite Combinatory Processes" in 1936, outlining a theoretical architecture functionally identical to Turing's model Emil L. Post, "Finite Combinatory Processes Formulation 1," The Journal of Symbolic Logic 1, no. 3 (September 1936): 103 105.. Stephen Kleene subsequently unified these disparate threads, proving the strict mathematical equivalence of Church's lambda calculus, Herbrand Gödel recursive functions, and Turing's mechanical architectures Stephen C. Kleene, "General Recursive Functions of Natural Numbers," Mathematische Annalen 112 (1936): 727 742.. -

- -

- The academic community was thus equipped with three mathematically equivalent foundations for computation theory: recursive functions, the lambda calculus, and the Turing Machine. While all three frameworks remain active subjects of study, Turing's model is unique in providing practical intuition through the abstraction of physical machines and programs. This made it the foundation of choice for computation theory textbooks by Stephen Kleene Stephen C. Kleene, Introduction to Metamathematics (Amsterdam: North Holland, 1952)., Martin Davis Martin Davis, Computability and Unsolvability (New York: McGraw Hill, 1958)., and Marvin Minsky Marvin L. Minsky, Computation: Finite and Infinite Machines (Englewood Cliffs: Prentice Hall, 1967)., leading to the modern standard presentations by authors such as John Hopcroft and Jeffrey Ullman John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison Wesley, 1979)., as well as Harry Lewis and Christos Papadimitriou Harry R. Lewis and Christos H. Papadimitriou, Elements of the Theory of Computation (Englewood Cliffs: Prentice Hall, 1981).. -

- - The Turing Machine transforms mathematics into computing - -

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

- -

- For Turing's purposes working on the Entscheidungsproblem, establishing functional equivalence between algorithms and Turing Machine programs was sufficient. However, when the Turing Machine serves as a foundational model for computation theory, we are led to ask another question: whether the Turing Machine is representative of modern architectures, and to the extent it differs, how this would affect the applicability of computation theoretic results. -

- -

- In reading Alan Turing's 1936 paper, it is striking how modern the text feels, specifically because he discusses algorithms, stored programs, and the mechanical limits of computation. - While his contemporaries largely built purely mathematical and logical frameworks, Turing uniquely tied computation theory directly to the abstraction of machines executing stored programs. Because physical hardware capable of executing stored memory programs had not yet been invented, this explicit architectural grounding makes Turing's work remarkably prescient. Still, Turing could not formally connect the Turing Machine to modern architectures, simply because those architectures did not yet exist. Here, by modern, I refer to architectures utilizing random access system memory, dedicated instruction fetch streams with dynamic branching, and discrete processing units. Though Charles Babbage's 1842 Analytical Engine touched on these concepts, they would wait until the 1940s to reemerge. The practical engineering context of 1936 was limited to calculating machines programmed via patch panels. Hence, for example, there is no explanation in his paper as to why a von Neumann architecture machine (1945) running a program would exhibit the computation theoretic results derived from a computation theory based on the Turing Machine (1936). -

- -

- Furthermore Turing's a machine from his 1936 paper utilizes binary. George Boole's work (1847, 1854) was well established by then, so from a theoretical standpoint, it was a sensible simplification. However, utilizing binary within the context of a machine description effectively bridged the gap to the more practically minded engineers of the time. Alan Turing's paper arrived at the same time that switched telephone networks had reached a scale that made them difficult to maintain without systematic approaches. These networks were built upon electromechanical relays, which were decisively binary devices. At least seven men in addition to Alan Turing appear to have independently contemplated the intersection of Boolean algebra, logic, and physical computing: Victor Shestakov (1935, proposed mapping Boolean algebra to electromechanical relay circuits), Konrad Zuse (1936, adopted base 2 architecture to bypass the physical complexity of decimal mechanical gears), Akira Nakashima (1936, published the mathematical equivalence of Boolean algebra and two terminal switching networks), Louis Couffignal (1936, proved calculating machines must shift to binary linkages to reduce physical friction), Claude Shannon (1937, published the definitive mathematical proof mapping Boolean algebra to electrical relays), George Stibitz (1937, constructed the first electromechanical binary adder), and John Vincent Atanasoff (1937, adopted binary to keep the vacuum tube count of electronic circuits physically viable). -

- - -

- To complete the Turing Machine story then, we will transform the Turing Machine into a modern architecture in a stepwise fashion, while ensuring that at each step the modifications are inconsequential to computation theoretic existence proofs and complexity class results. We do run into some problems, so the architecture we derive will be a little different from those we currently build. Though the point here is, we could build it. -

- -

- The infinite tape is not as large of a hurdle as it might seem at first. For computational problems, the Turing Machine halts in a finite number of steps. Because the Turing Machine is limited to stepping the read/write head over one cell per machine execution step, in a finite number of steps, only a finite amount of tape is ever used. But for a given computation, how much tape is that? Resolving this by assuming more tape is simply attached when needed is analogous to cheating in a 'guess the bigger number' game by declaring, "My number is always one bigger than the given number, so I will tell you my guess after you state your number." Some mathematicians suggest that what is meant by infinity is precisely a rule of this sort. For engineers building physical hardware, however, to state that a resource starts finite and expands incrementally over time is a very different proposition than being asked to install infinite memory on a machine in the first place. -

- -

- In 1967, Marvin Minsky addressed this very topic in saying: "We need not think of the machine's tape as infinite. We imagine instead that the machine begins with a finite tape, but that, whenever an end is encountered, another unit of tape is attached." Marvin L. Minsky, Computation: Finite and Infinite Machines (Englewood Cliffs: Prentice Hall, 1967), 167. In 1967, this was a perfectly natural thing to suggest, as computers utilized magnetic tape memory on manually mounted reels, and it was entirely possible for a computation to stop and request a new reel of tape to be mounted. Contemporary computer architectures do, in fact, achieve a similar effect through virtual memory. When physical RAM is depleted, the operating system pauses the active process and autonomously provisions apparent capacity by swapping memory pages out to auxiliary storage. However, this illusion of infinite tape remains bound by the physical limits of the secondary storage and the boundaries of the processor's address space. Once the available swap space is exhausted or the address space is saturated, the operating system abruptly terminates the process. -

- -

- Like a Turing Machine, a computer architecture is an abstraction. The box sitting on a person's desk is a realization of some computer architecture. To say a Turing Machine does something is to say that the Turing Machine was analyzed and the result of the analysis is that 'something'. A computer architecture can also be analyzed. A computer architecture is said to be Turing Complete when through analysis it is determined that it can do anything that a Turing Machine can do. The practical implications for a realization of a computer architecture are that running a program will only throw an error because a) the program logic told it to, b) the program has a flaw, or c) there is a mathematical fact standing in the way of execution. It is tolerable to call a computer architecture Turing Complete if it has the built in ability to pause a program until a 'more memory' request is fulfilled. If there can be any other errors from a realization running a program, such as running out of address space or integer overflow, then the architecture is not Turing Complete. -

- - - The computer design abstraction stack - -

The six levels

- -

- There are a number of discernible levels to the computer design abstraction stack: -

- -
    -
  1. mathematical logic
    2. -
  2. computation theory
    3. -
  3. architecture
    4. -
  4. organization
    5. -
  5. implementation
    6. -
  6. realization
    7. -
- -

- Mathematical logic underpins the computation theory layer. Computation theory speaks of the time and space complexity of algorithms and the existence of solutions to decider problems, which in turn guides the goals of the architecture and organization layers. -

- -

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

- -

- It is not a requirement of a computer organization, nor an architecture, that it be capable of physical realization. The abstract Turing Machine organization developed in a later section serves as an example. Instead, an abstract organization can serve other purposes, in this case as a stepping stone to another organization that can be realized. -

- -

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

- -

- If a computer manufacturer keeps the architecture as a constant, all other levels can change, and a customer will be able to run the same software. The same organization can be used with different implementations. Minor changes in manufacturing process can sometimes be used with an older implementation, for example a simple transistor shrink. -

- -

The levels are not independent

- -

- The layers are merely idealizations. In both practice and theory it is not possible to completely disentangle them. On a new machine of the same architecture, it is common that some software will require updates to run, and almost certainly specific operating system support will be required. -

- -

- An architect almost always has a reference organization in mind, and design architects work with design engineers to know what is practical, and design engineers work with manufacturing engineers to know what can be built. -

- -

- The common understanding of the word 'architecture' is what Hamacher and Zaky call an organization. For example, even the most experienced of architects will say things like a microprocessor has a "superscalar architecture", though whether a processor is a scalar, superscalar, or VLIW machine is clearly a question of computer organization. -

- -

- In fact, architecture instructs organization. When an architect designs an instruction set that has load instructions, it implies that there will be an instruction fetch, and thus an instruction bus. Furthermore the load data has to come from somewhere, so there will be data fetch and a data bus. Could both be the same bus? If not, then we have a "Harvard Architecture". The fact is, almost no one involved in computer design completely divorces architecture from organization. -

- -

- This cascades down the stack, as organization instructs implementation, etc. For example, if the architecture has an instruction that names one of N registers as an operand, then the organization has a register file that data flows to and from, and busses to carry that data, the design will specify a register file and layout the busses, and the manufacturing people will build them. -

- -

Where the Turing Machine fits in

- -

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

- - Computation theoretic consequentiality - -

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

- -

- When a transform applied to machine m_i produces machine m_{i.1}, and this latter machine gets the same results for the same computational inputs, and furthermore, if any computation theory analysis applied to m_{i.1} yields the same 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

- -

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

- - - m_i(x_{i,j}) = r_{i,j} - - -

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

- - - \begin{aligned} - m_8(x_{8,0}) &= r_{8,0} \\ - m_8(x_{8,1}) &= r_{8,1} \\ - m_8(x_{8,2}) &= r_{8,2} - \end{aligned} - - -

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

- -

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

- - - m_i \xrightarrow{T} m_{i.1} - - -

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

- - - \forall j \colon r_{i,j} = r_{i.1,j} - - -

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

- -

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

- - - \forall i, \forall j \colon r_{i,j} = r_{i.1,j} - - -

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

- -

Definition of the computation theoretic consequential/inconsequential transform property

- -

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

- -

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

- - - a_{i,k} = q_{i,k}(m_i, \{x_{i,j}\}) - - -

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

- -

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

- - - m_i \xrightarrow{T} m_{i.1} - - -

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

- - - \forall k \colon a_{i,k} = a_{i.1,k} - - -

- then T is computation theoretic inconsequential for m_i. -

- -

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

- - - \forall i, \forall k \colon a_{i,k} = a_{i.1,k} - - -

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

- - - The computation theory Turing Machine - -

The Hopcroft and Ullman Turing Machine

- -

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

- - - M = (Q, \Sigma, \Gamma, \delta, q_0, □, F) - - -

Where the components have the following meanings:

- - - -

I have introduced the qualifier programmed in front of the finite state machine controller because each Turing Machine that accomplishes a different task, has a different finite state machine controller. The rest of the Turing Machine remains fixed. Hence, when the mathematician defines a custom task controller, he is essentially programming the machine.

- -

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. In the architecture description given below, those symbols in the larger set, but not in the input set are called control symbols. Hopcroft and Ullman have included the empty symbol as a control symbol. However, they have simultaneously listed it as a separate component.

- -

State transitions are gated by the read value from the tape. Each state transition function includes actions to be taken, hence their programmable controller is a Mealy style state machine. The step action is mandatory, though it can be in either direction. The write action must be specified, but the write could be the same symbol that is read, hence it is actually an optional action.

- -

Hopcroft and Ullman explain a step of the machine by showing the state variable melded in with a representation of the tape to the left of the symbol the head is indicating. Suppose \delta(q, X_i) = (p, Y, L); i.e., the next move is leftward. Then, -

- - - X_1 X_2 \cdots X_{i-1} q X_i X_{i+1} \cdots X_n \underset{M}{\vdash} X_1 X_2 \cdots X_{i-2} p X_{i-1} Y X_{i+1} \cdots X_n - - -

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

- -

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

- -

The empty symbol

- -

The initial tape is often said to be empty, where an empty tape is one where every square has an empty symbol written to it.

- -

Also, there comes a time in some proofs when an empty symbol is written over a data symbol on the tape. This is said to erase the data symbol. Thus a machine allows that the replacement symbol specified in a state transition can be the empty symbol.

- -

Computational theorists often describe a two step process. First that of having a Turing machine write an input string on to a tape, where the tape was initially filled with all empty symbols, and then secondly using another Turing Machine that is to recognize if said input string fits a particular pattern. In this manner a tape is used as a communication medium, and it follows that communication theory can be applied to this messaging scenario. Messages sent on a channel must be structured in a manner that they can be placed on the channel, and then later recovered. Such a structure is called a communication protocol. The protocol implies a higher authority as both the sender and the receiver must have knowledge of the same protocol designed in. In a sense, a protocol is the meta-message that is sent before the message is sent.

- - -

The intention of placing the empty symbol in \Gamma but not in \Sigma appears to be that of reserving the empty symbol as a structural component in a communications protocol. This protocol was designed by mathematicians with the intention of making it impossible for programmers to create input tape messages that can not be recovered by a receiving recognizer Turing Machine. In short, the empty symbol is being used as an in band EOT, end of transmission, symbol.

- -

If so, this protocol fails to prevent programmers from making Turing Machines that make messages that can not be recovered by a receiving Turing Machine, because the Turing Machines were bestowed with the ability to erase characters. An input machine could, for example, happily make an array of strings while using the empty symbol to separate the elements of the array. Nothing in the Turing Machine definition prevents this.

- -

Furthermore, the Universal Turing machine can be the aforementioned higher authority. In which case, Turing Machine their tapes, are written to a Universal Turing machine's tape. Hence, it is not only possible to want to terminate strings, as mentioned in the prior paragraph, the very problem is embedded in proofs such as the Halting problem proof.

- -

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

- -

If we are to design communication protocols, there are better ways to do it. Out of band control, for example, packet communication, or run length encoding, has much better characteristics.

- -

But if the empty symbol is merely an EOT encoding, then why call it empty?

- -

A bookshelf is said to be empty when there is no obstacle to enshelving a book or other object on it. This is not to say there is nothing there in first place. Air gets displaced, if the bookshelf is under water, it can still be empty, because a book can be placed on it. The air, or the water, does not present an obstacle. If the bookshelf is limited to only hold books, then an shelf is empty when no book is available, and not empty otherwise. Attempting to pull a book from an empty shelf does not yield a book who's title is 'Meditations upon Emptiness', rather the attempt fails.

- -

In this sense then, a Turing Machine is always empty, as no symbol on the tape presents an obstacle to writing a new symbol.

- -

There are some concepts that can not be represented as a symbol. The concept of tape obstacle symbol is not representable with the current Turing Machine design; however, with a small modification, we could set aside a control symbol, that once written, the machine would refuse to overwrite it.

- -

Another concept that can not be represented with a symbol on a Turing Machine is that of the unknown. The very workings of the Turing machine depend upon state transitions based on matching a symbol. A person could to modify a Turing Machine to non-deterministically explore all possible branches upon seeing such a symbol, but that might not be the correct things to do, as a cell with an unknown value only has one value in it, the problem being that one value is not known. There is no general concept built into the Turing Machine of taking multiple branches and then through some means testing to see which was the correct branch. Any attempt to do this will have to incorporate a testing concept. The unknown is not merely a theoretical curiosity, because this is how real computer memories are initialized.

- -

Emptiness is another concept which a Turing Machine symbol can not represent. As mentioned above, all symbols can be written with equal ease to tape. A state machine could have an arc whereupon reading an empty symbol, the machine goes to the error state, indicating that the read failed, but this is not the definition given for the computational Turing Machine.

- -

For reasons of supporting recursion, the computation theoretic Turing Machine given in the next section will have a set of predefined symbols that are included with the alphabet of symbols. Where a communication protocol is required, the Turing Machine programmer must define it.

- -

The singular-unknown

- -

In the first edition of this book, I introduced a "no read until after write" rule so as to side step the blank symbol issue. This did not displace the need for a communication protocol when tapes were sent as messages.

- -

The standard 9 track tape introduced by IBM in 1964 came from the factory unformatted, the format operation would then write a header and an EOF marker, to mark the end of the device file. Then when an standard library call, such as open(), followed by write(), would writer over the EOF marker, and continue to write the data, then would write a new EOF marker, essentially pushing back the EOF marker. EOF could be pushed back until the physical EOT marker was struck. This is similar in some ways to the how the empty symbol is being used on the computation theoretic Turing Machine as we see in the Hopcroft and Ullman book if we consider the blank to be an EOF marker. However, there is a difference in that the real machine would never use an EOF to erase data characters. Note then while using the standard library, the blank part of the tape could not be read until after it was written, so early tapes indeed enforced the "no read until after a write" rule.

- -

Note, however, if the programmer seeked the head back into the device file to do write the device EOF would be nowhere in site. The burden of the "no read until after a write" rule would then fall on the shoulders of the programmer, as would the structuring of the data.

- -

Core memory, and then 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. That approach; however, 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 is created in memory then scrubbed with zeros. If the computational Turing Machine's blank symbol maps to a word of zeros, then the blank symbol would still not be a good model, because generally the data message, say sent between the input writer, and the recognizer receiver, will also contain many zeros. The nice part is if a programmer attempts to dereference a zero pointer, there will be a segment fault. So in this system the program is again burdened with maintaining the "no read until after a write" rule.

- -

The computation theoretic Turing Machine can instruct computer architecture through a detection of failure of "read after write" if instead of an empty symbol, the machine is modified to support the singular-unknown symbol.

- -

A singular unknown is a valid single value read from the tape, but despite being able to discern it as a symbol, no decision can be based on its value. However, it is a valid operation to copy it to another cell on the tape. The current computer theoretic Turing Machine definition has no ability to effect his specification. By the current definition, every state transition reads the value under the head, and then gates to the next state based on that value. Hence, there is no escape from making a decision based on the value under the head, and as each state transition comes with a mandatory step, there will be a different value under the head in the next state.

- -

The TTCA computation theoretic Turing Machhine

- - - M = (Q, \Sigma, κ, A, \lambda, \delta, q_0, q_h, q_e) - - -

Where the components are redefined to strictly model a Moore machine organization:

- - - -

- By separating the operational action \lambda from the transition evaluation \delta, the tuple accurately reflects a Moore machine organization. The action is securely bound to the state itself, exactly matching an architecture where each entry in the state dictionary executes one machine action before resolving the next state list. -

- - - The Turing Machine architecture/organization - - - - -If a computation requires a two way infinite tape, the single ended tape machine can emulate it 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. When analyzing the time complexity of an algorithm, this overhead merely doubles the constant on the linear term, leaving the asymptotic order of complexity entirely unchanged. The outcomes of decider programs are unaffected. Therefore, utilizing a single ended tape is an inconsequential variation of the two way tape machine. -

- -
- Figure 1: A Turing Machine -
Figure 1 A Turing Machine
-
- - -

Symbol in mathematics

- -

- A symbol is a distinct mathematical object capable of being instantiated. Within a given context, any instance of a specific symbol evaluates as equal to any other instance of that identical symbol, and evaluates as not equal to any instance of a different symbol. -

- -

- Put more formally, given a set of instantiable objects and a collection of instances made from them, for these objects to be symbols, two conditions must be met. First, it must be possible to define an instance comparison operation, denoted =, that acts as an equivalence relation to partition the collection into discrete equivalence classes. There must be a one to one correspondence between the resulting equivalence classes and the original instantiable objects from which the member instances were derived. -

- -

- It follows from this definition that the distinct equivalence classes can be used as a proxy for the instantiable objects themselves. That is, a person can name either the instantiable object or the equivalence class, and then through this correspondence, find the other. -

- -

Symbol in computing

- -

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

- -

- A symbol instance newly minted by the factory is said to come direct from the factory. A symbol instance direct from the factory is also called an original. -

- -

Required properties of symbol factories

- -

- Any two symbol instances returned directly from two distinct factories will always evaluate to False during an equality comparison. In other words, two distinct originals will always be not equal. -

- -

- 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 any two originals, say A and B, it is established that A is not equal to B, as discussed above. Note also that A is not equal to any copy stemming from B, and B is not equal to any copy stemming from A. -

- -

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

- -

Instance implementation

- -

- Within a process, a reference to the factory can be used as a symbol instance, which will cause the factory to become trivial. Making a new instance will merely require copying the factory reference, and there will be nothing in memory that the base factory reference is pointing to. -

- -

- In general, memory addresses are built in symbol instances, hence within the context of a single process run, a program can make use of these symbols. However, this diminishes the size of the address space and leaves the memory at those addresses unused. A common hedge is then to use references into a dictionary, where the data looked up in the dictionary is the name of the symbol. -

- -

- Such symbol names are non structural strings, so they do not need to follow the rules of symbols. For example, a program written where references to strings were used as symbol instances, could give multiple, or all, strings the same name, and the program would function. Conventionally, the names are made to be distinct so as to avoid confusion. The hazard here is that a programmer will then conflate the string name with the symbol instance, and perform symbol operations with it. -

- -

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

- -

- As another alternative, each factory can be given a base string, and then make returns a copy of the base string. Here we refer literally to the string as the symbol instance. There is no separate name, and the string data, not the reference to the string, becomes the symbol instance. This is however merely an architectural constraint, under the hood an implementation could use string references as long as it always appears to the programmer that the string value is being used. -

- -

- At the time of this writing many machines use 64 bit words. This is equivalent to 8 ASCII characters, while the average size of an identifier is about 5 characters. Hence the approach of using a string as a symbol might not be as inefficient as it seems to be at first. Using strings has advantages. Symbol instances can carry semantic clues for the programmer. There is no hazard of conflating the string instance with the name, as they are the same. Also, a string instance will have integrity across contexts, such as between invocations or when passed between processes (note the section below on crossing context boundaries). A drawback is in cases there is no language support, the strings are typically ad hoc so the guarantee of distinctness becomes merely a contract with the programmer. -

- -

Distinctness across contexts

- -

- If a symbol persists across contexts (such as across scopes or processes), it must remain distinct from all other symbols in its new context. -

- -

- One way to meet this requirement is to find a scope encompassing both contexts and to place the symbol factory there. Another solution is to give each context a distinct root symbol and to use an array of symbols in place of the imported symbol. Yet another approach is to associate an imported symbol with a new symbol in the given new context using a correspondence map. -

- -

- When utilizing memory addresses as symbols in a virtual memory environment, the convention is to disallow addresses in one process from being used in another. If that isolation is insufficient, it is often adequate to use indexes instead of addresses, taking the address to the base of the data structure. Though the absolute address of the data structure might differ across contexts, the relative offset remains constant. Another approach is to reserve memory address blocks and to guarantee imported pages have the exact same addresses as before, though they might be imported sequentially to reuse the memory block. In architecture, this is generally known as the pointer swizzling problem. -

- -

Symbol copy consequentiality

- -

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

- -

- Fortunately, the Turing Machine is defined with a finite alphabet and a couple of additional symbols. As these are part of the machine definition, and thus do not change at run time, there is no growth in size, and the time to copy them is inconsequential. -

- -

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

- -

Alphabet

- -

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

- -

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

- -

Symbol implementation examples

- -

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

- - - /* The enum definition acts as the factory. */ - typedef enum { - SYMBOL_EMPTY = 0, - SYMBOL_ZERO = 1, - SYMBOL_ONE = 2, - SYMBOL_A = 3, - SYMBOL_B = 4 - } TapeAlphabet; - - /* Instantiating copies of the symbols: */ - TapeAlphabet cell_1 = SYMBOL_A; - TapeAlphabet cell_2 = SYMBOL_A; - - /* Equality comparison over instances */ - if(cell_1 == cell_2){ - /* Evaluates to True */ - } - - -

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

- - - #include <string.h> - #include <stdlib.h> - #include <stdio.h> - - // maximum legal index into the symbol list - #define LIST_EXTENT 3 - - typedef const char *Instance; - typedef struct{ - Instance *head; - Instance *tail; - Instance *extent; - } List; - - static List SYM_LIST = {NULL ,NULL ,NULL}; - - Instance make_list(const char *name){ - size_t size = LIST_EXTENT + 1; - SYM_LIST.head = (Instance *)malloc( size * sizeof(Instance) ); - SYM_LIST.tail = SYM_LIST.head; - SYM_LIST.extent = SYM_LIST.head + LIST_EXTENT; - *SYM_LIST.head = strdup(name); - return *SYM_LIST.head; - } - - Instance make_symbol(const char *name){ - if(!SYM_LIST.head) return make_list(name); - - Instance *pt = SYM_LIST.head; - while(1){ - if( strcmp(*pt ,name) == 0 ) return *pt; - - if(pt == SYM_LIST.extent){ - fprintf(stderr ,"symbol list overflow for %s\n" ,name); - return NULL; - } - - if(pt == SYM_LIST.tail){ - *++SYM_LIST.tail = strdup(name); - return *SYM_LIST.tail; - } - - pt++; - } - } - - int main(){ - Instance a = make_symbol("a"); - Instance b = make_symbol("b"); - Instance c = make_symbol("c"); - Instance d = make_symbol("d"); - Instance e = make_symbol("e"); // overflows table - - Instance *pt = SYM_LIST.head; - Instance *pt_tail = SYM_LIST.tail; - while(1){ - puts(*pt); - if(pt == pt_tail) break; - pt++; - } - - if(e == NULL) printf("e is NULL\n"); - } - - -

Property

- -

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

- -

Dictionary and reference

- -

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

- -

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

- -

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

- -

A Turing Machine tape cell

- -

- A cell is the square from Alan Turing's 1936 paper Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265.. Mathematically, a cell is a referencable distinct identifiable set, with one to three property members depending on the type of cell. -

- -

- A leftmost cell is a set of two properties named 'right neighbor' and 'data'. A rightmost cell is a set of two properties named 'left neighbor' and 'data'. An interstitial cell is a set holding three properties: a 'left neighbor', a 'right neighbor', and 'data'. While an island cell owns a single compulsory property, that of 'data'. -

- -

- The value of a neighbor property is a non-null single reference to a cell. The value of a data property is strictly an instance of an alphabet symbol, or alternatively, an instance of the empty symbol. -

- -

Tape

- -

- A tape is a set containing exactly one leftmost cell and an infinite number of interstitial cells. For each cell in the set, called cell A, if cell A has a right neighbor that is cell B, then cell B's left neighbor is cell A. Similarly, if cell A has a left neighbor of cell B, then cell B's right neighbor is cell A. Furthermore, any cell in the set must be reachable by traversing right neighbors starting from the leftmost cell, in a finite number of steps. -

- -

- To say that a tape is infinite, and to simultaneously require that any cell can be reached in a finite number of steps, means that after reaching said cell, there will always be further cells to the right. Consequently, though any cell can be reached in finite hops starting at the leftmost cell, a finite traversal of the tape can not visit all of the cells. This seeming contradiction is at the very heart of the definition of the countable infinity in mathematics. -

- -

- In conventional computation theory, once a tape is defined, the cell neighbor properties values are fixed. Cells don't move, new cells cannot be added, and cells existing on the tape cannot be removed. This fits the definition of a space, so we can say that a Turing Machine tape has a constant, fixed, linear topology. This permanence of cells matches the reality of hardware memories. On the other hand, it does not track well with general memory containers such as linked lists where destructive operations are often permitted. -

- -

- Nor can a cell data property be removed; however, unlike for cell neighbor property values, the cell data property value can be changed while the Turing Machine is running. In fact some people would say this is the whole point of running a Turing Machine. -

- -

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

- -

- The tape is intentionally defined in such a manner that there is no meaning to 'in between' two cells. The head of the machine is always on exactly one cell, with the option of stepping to neighbor cells. Taking a step is an atomic operation; there is no meaning to 'during the step'. Turing Machines are state machines controlled by a clock. A person only asks questions of them when the machine is in a defined state. -

- -

- Mathematically, a Turing Machine tape can be expressed as a path graph. However, a tape model and a path graph model imply different ontological contexts. The neighbor property of a Turing Machine tape cell specifically informs a clock driven atomic step function where to place the machine head next. The machine only has defined meaning at the state points on the programmed controller. In contrast, a path graph exists in the wider context of graph theory. A path graph has edges and each edge can be focused on, said to be traversed over, and given general properties. These are things we explicitly excluded in the tape definition. If we were to move the tape from the context of the machine and into the more abstract mathematical context by modeling the tape with a path graph, then we would do so for the purpose of analyzing the tape, which is a higher order and more abstract activity. However, in the current exercise we are not reaching towards the more abstract; rather, we are reaching in the other direction, towards machine architecture. -

- -

Tape transport unit, TTU

- -, from which tapes can be mounted and unmounted. Multiple TTUs can be plugged in. Each TTU contains: - -mount/unmount - -
    -
  1. a read/write head
    2. -
  2. a single symbol FIFO read data buffer, written by the TTU, read by the programmable controller
    3. -
  3. a single symbol FIFO status buffer, written by the TTU,, read by the programmable controller
    4. -
  4. a single symbol FIFO command buffer, written by the programmed controller, acted upon immediately by the TTU.
    5. -
- - -

- The tape head consists of a reference to exactly one of the tape cells and a set of four functions: read, write, step-left, and step-right. In addition, the tape head can throw an error, left-of-leftmost, if the Turing Machine attempts to step left from the leftmost cell. When stepping, the cell reference in the head is updated based on the neighbor properties of the currently referenced cell. The cell referenced by the head is called the cell the head is on, or more simply, the head cell, or more generally as the indicated cell. -

- -

- A person can also say that the head indexes the head cell. This utilizes the classical mechanical definition, where an index is a mark for aligning gears. This physical meaning contrasts with an index integer used for addressing an array. The architectural definition of the Turing Machine developed here relies strictly upon the topological properties of the tape, independent of the definition of Natural Numbers. Addresses, which do rely on Natural Numbers, are discussed further on in this volume. This represents a minor divergence from Alan Turing's original paper, as he took it as a given that numbers naturally paired with the squares. We explicitly establish that pairing only after deriving Natural Numbers using the Turing Machine itself. -

- - - -

The customer programmed components

- -

The customer programmed portion of the programmed control consists of:

-
    -
  1. default next state list
    2. -
  2. state dictionary
    3. -
  3. an initial state reference
    4. -
  4. a halt state reference
    5. -
  5. an error state reference
    6. -
- -

A programmer uses a Natural Number to reference a state. Hence the initial state reference and halt state reference are set to Natural Numbers. It is not required but it is conventional to use 0 as the initial state.

- -

A next state specifier is a pair consisting of an identifer to be matched as a first of the pair, and a next symbol reference as a next component, where each identifier has the form:

- - [<TTU_ID>:][<buffer>:]symbol - -

As multiple TTUs can be plugged in, an identifier starts with a TTU id. There are two buffers that on the TTU interface that interface can read, data and status, so that is specified next. Following that is the symbol to be matched. If the TTU_ID field is not present, the colon is also omitted, and the value is taken as 0. If the buffer name is ommitted, the colon is also omitted, and the value is taken as data.

- -

The default next state list is a list of next state specifier. This list is checked first, i.e. has precedence, over the state dictionary next state list

- -

Each entry in the state dictionary consists of one TTU command, followed by a next state list.

- -

The TTU command set consists of:

-
    -
  1. no-op
    2. -
  2. step
    3. -
  3. step left
    4. -
  4. write(x)
    5. -
- -

Note that the write value, x must be a symbol from either the data alphabet or be the empty symbol.

- -

The structural portion of the programmed controller:

-
    -
  1. the TTU command set
    2. -
  2. the current state register
    3. -
  3. the reset control line
    4. -
  4. the clock
    5. -
  5. multiple comparators
    6. -
- -

The comparators are used to used to match the identifier with a the values read from each of the buffers. Note that if the same next state is specified for the same start state, then it is the same as though the identifiers are in disjunction. Also the no-op command to create conjunctive decisions. Hence as a shorthand notation arcs can be labeled with propositions made from the buffer values.

- -

Upon reset the current state register is written with the initial state. When the current state register is set to the halt state, the machine stops. If no next state is found for a given state, the error state is written to the current_state_register and the machine halts.

- -

On the rising edge of the clock, the TTU writes the data and status buffers, and the state command is written to the TTU command buffer. On the falling edge of the clock, the TTU completes the state command, and the next state is written to the current state register.

- -

Here is an example customer defined programmed controller for incrementing a unary number:

- - - Data alphabet: {s} - States: {0, 1, 2, 3, 4} - Initial state: 0 - Halt state: 3 - Error state: 4 - - State dictionary: - { - 0: n op - s -> 1 - □ -> 2 - 1: step_right - s -> 1 - □ -> 2 - 2: write(s) - * -> 3 - } - - Default next state table: { - status:left-of-leftmost -> 4 - } - - - - - - - - - - - - - - - - - - - - - - -

- The distinct empty symbol can be any symbol that is excluded from the alphabet. Only instances of alphabet symbols or the empty symbol are permitted to be written to the tape. -

- -

- Intuitively, a person might consider that the alphabet symbols are useful while the empty symbol is merely taking up space while waiting to be displaced, in the same manner that a person considers a bookshelf to be empty rather than being full of air. (And if a person puts a bookshelf underwater, is it still empty, or is it full of water?). -

- -

- If a physical machine receives power without the reset signal being held, it can land in an illegal state. This is hazardous as the machine might become permanently stuck in a configuration that ignores subsequent reset commands, it might operate unpredictably, or it might even suffer physical hardware damage. To avoid these outcomes, systems are designed to hold the reset line active while the power comes up. Asserting the reset signal, rather than recycling power, is what actually causes a machine to land in a known initial state. Consequently, we must include a reset feature. -

- -

- This design assumes that when reset is released, that the machine immediately starts running. This is fine for our purposes, but surely the deluxe model would have a separate 'go' button and the associated logic. -

- -

- The tape transport unit, TTU, handles mounting, unmounting, reading, writing, and moving, the tape. In this volume we will talk about stepping the head. This should be interpreted in a relative sense, as a real TTU will move the tape rather than the head. Our machine is designed such that the customer can plug in more than one TTU unit. Each unit has its own read buffer, status buffer, and head. A tape can be mounted or unmounted from each unit. At the election of the operator, the tape can be unmounted from one TTU, shelved perhaps, then unshelved and mounted back on the any TTU, the same one, a different one on the same machine, or a TTU on another machine. -

- -

- The constant executor should not be conflated with the Turing Machine program. For a microcode controlled machine, the procedure will be found in microcode memory, and it will be executed as though a program. Each line of the procedure, when read, results in a set of bits being connected to the machine's control lines. Some of those control lines will control what the procedure does, and some will extend out into the data path and be used to configure execution units and gate data on to busses. -

- -

- For a hardwired machine, the operation program will be expressed with logic gates and flip flops (single bit memory registers). Whether a machine is microcode controlled, or hardware controlled is a question of implementation. The values on the control lines remain the same independent of those implementation decisions, so those decisions are inconsequential to our architecture discussion. -

- -

- The Turing Machine architecture specifies an infinite tape, which can neither be implemented, nor realized. We will introduce a computationally inconsequential modification in a later chapter that causes the tape to be finite. -

- - -

Machine

- -

The immutable structural components:

-
    -
  1. a read only empty symbol that is distinct from any symbol in the data alphabet. The examples in this document use the symbol '□'
    2. -
  2. a read only control alphabet for this base model, consisting of the one symbol leftmost
    3. -
  3. a read writable current state reference variable, which points into the custom predefined program controller
    4. -
  4. a fixed hardware halt state comparator
    5. -
  5. a tape transport unit, TTU, from which tapes can be mounted and unmounted. Multiple TTUs can be plugged in. Each TTU contains: -
      -
    1. a read/write head
      2. -
    2. a single symbol FIFO read data buffer, written by the TTU, read by the programmable controller
      3. -
    3. a single symbol FIFO status buffer, written by the TTU,, read by the programmable controller
      4. -
    4. a single symbol FIFO command buffer, written by the programmed controller, acted upon immediately by the TTU.
      5. -
    -
    6. -
- -

The fixed logic internal to the machine:

-
    -
  1. a constant executor where each step of the procedure can be referenced by number
    2. -
  2. a read/writable/incrementable executor step counter
    3. -
  3. a reset button that activates logic that initializes the machine
    4. -
  4. a read only clock to synchronize control and to cause counting until the halt state is reached
    5. -
- -

Accessories:

-
    -
  1. tapes, as described in a prior section
    2. -
  2. a Universal Turing Machine package, consisting of the Universal Turing Machine programmable controller and auxiliary alphabet, which comes with tapes containing example programs
    3. -
- -

Each highlighted term is a short name for the associated item.

- - - -

Operation logic

- -

- The following procedure is embodied as further control logic in the Turing Machine. This procedure is fired upon receiving a step pulse. At the time the procedure is entered, the head is stable upon a cell. We list phases so as to avoid any apparent race conditions. This does not dictate to the designers that the clock must have phases, though that isn't excluded either. -

- -

Deterministic (Uniplex) programmed control procedure

- -

Upon each step pulse:

- -

Phase 1:

-
    -
  1. read the symbol instance indicated by the head into the read data buffer
    2. -
- -

Phase 2:

-
    -
  1. lookup the current state in the instruction table
    2. -
  2. lookup the current state concatenated with the read data buffer in the next state table
    3. -
  3. lookup the current state in the default next state table
    4. -
- -

Phase 3:

-
    -
  1. if the current state is found in the next state table, use the retrieved value as the next state. Otherwise, if the current state is found in the default next state table, use the default state as the next state. Otherwise, use the error state as the next state.
    2. -
  2. if an instruction was retrieved from the instruction table, the tape transport executes it. Otherwise, the tape transport executes the default 'no-op' instruction.
    3. -
- -

Phase 4:

-
    -
  1. write the next state to the current state register
    2. -
  2. controller remains quiescent waiting for the next step pulse
    3. -
- - -

An alternative: stored program and sequencer

- -

- The Universal Turing Machine, proposed by Alan Turing, introduced a profound architectural inversion: relocating the defining state tables from hardwired logic, or manually configured patch panels, directly onto the tape itself. This enables replacing the custom programmed controller with a fixed controller that derives its behavior dynamically from the tape data. Consequently, a single, immutable hardware architecture can simulate the execution of any conceivable Turing Machine. -

- -

- In addition, encoding a machine's control logic as parseable data on tape establishes an ontology of analysis, a framework where a machine can analyze another machine to establish some properties the other machine might have. We say 'some' because at least one limitation has been proven. Alan Turing proved that such an analyst cannot in general determine if said other machine has the property that it would halt for any input when run. -

- -

- We can optimize this representation. Instead of storing the state tables verbatim, we can list a sequence of instructions directly on the tape. To achieve this, the architecture expands to support two distinct categories of instructions: the physical tape transport instructions we defined previously, and a newly introduced category of control instructions. The programmed controller is then replaced with a fixed hardware controller called a sequencer. -

- -

- Because the original state tables allowed for non linear execution paths, the instruction sequence on the tape cannot always execute in a straight line. Therefore, the architect must include at least two control instructions: a halt instruction and a test and branch instruction. The sequencer starts at the first instruction in the program, perhaps at the leftmost cell on the tape, and evaluates it. If it is a control instruction, the sequencer acts upon it directly to alter the flow of execution or stop the machine. Otherwise, if it is a physical instruction for the head unit, the sequencer passes it down to the tape transport. -

- -

- Because we have not yet derived Natural Numbers or memory addresses in this architecture, a test and branch instruction cannot jump to a numerical address. Instead, it must operate topologically. A topological branch instruction simply commands the sequencer to scan the tape for a specific target symbol, and resume executing instructions from that physical location. -

- -

- As noted in the prior section, an instruction consists of an instruction code and potentially an argument. There are many choices that can be made in instruction set design. Among those choices, almost all will be inconsequential from a computation theoretic point of view, but almost all will introduce strict efficiency trade offs in physical hardware. -

- - -

Operation logic

- -

- In the prior two sections we discussed the configurable part of the Turing Machine control. Here we complete the picture by describing the fixed portion. -

- -

Setup

-
    -
  1. select and mount a tape
    2. -
  2. push the reset button
    3. -
- -

Reset

-
    -
  1. step the head left until an 'left of leftmost' error from the tape transport unit, the head will then be on the leftmost cell
    2. -
  2. hit reset on the programmed controller, or the sequencer, depending on which is being used
    3. -
  3. wait until the release of the reset button
    4. -
- -

Main:

-
    -
  1. evaluate the value of the reset line coming from the reset button
    2. -
  2. if the reset line is true, execute the Reset procedure
    3. -
  3. if the reset line is false, evaluate the halt line coming from the comparator
    4. -
  4. if the halt line is true, freeze execution until reset is asserted, then return to step 1
    5. -
  5. if the halt line is false, send a step pulse to the programmed controller (or sequencer) on each clock tick
    6. -
- -

- A person can read this procedure with the caveat, "if we could realize such a machine, this is what we would do." Later, these directions can be modified and applied to the machine variation that has an expanding tape. -

- -

- To start the machine we must first select a tape. Common choices are an empty tape, a tape with data on it the machine is to decide matches a given language pattern, or a tape with a Turing Machine on it to be analyzed. After the tape is selected it is mounted on the Turing Machine, then the reset button is hit. -

- -

- After the reset button is released, the machine begins stepping. If the program is a computation, the machine will eventually halt. If the machine eventually halts, then we know the associated program was a computation. Otherwise we do not know. Any amount of time we wait where the machine has not halted, we will not know that it will ever halt. Hence, we cannot in general use 'running a Turing Machine' as a means to determine if a given program is computational. (We could instead try to answer the question 'is it computational' through analysis, but there too, Turing has shown that in general that will not work either.) -

- -

Operation logic steps, programmed controller steps, and head steps

- -

- In common books and papers about the Turing Machine, a step is defined as one step of the programmed controller, i.e. one pass through the four phase procedure given above. Decider proofs ask if the comparator will match the halt state within a finite number of steps. Time complexity proofs take a formulation of step count to reach the halt state, parameterized against the size of the input, and report the order of the highest term as it is asymptotically dominant. Hence we speak of constant, linear, polynomial, and exponential time complexity algorithms. A similar method of analysis, that of memory usage with step count, parameterized against input size, is used for space complexity. -

- -

- For a real machine, the step pulse will be derived from the machine clock. The clock will have a constant period, so there is a constant duration of time that will be the same for each pass through the execution procedure. Thus, if we replace the step count with a count of clock ticks, we will get the same decider and complexity results as we would have from step counts. This fits the definition we have been using for inconsequential. -

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

- Given that we have an architectural definition for a Turing Machine, and will modify this in a later chapter to define a realizable Turing Complete architecture, it is possible to invert the foundation of mathematics. Instead of mathematics preceding computation, we posit that given a Turing Machine exists, all of mathematics is an interpretation of what can be done with it. -

- -

- We begin by defining the tape cell as a location in a physical memory, which provides us with arrays of charge configurations. -

- -

- We then define the symbol in computational terms, as done in the prior section. This begins with memory addresses, represented as charge arrays, acting as primitive symbols, and extends to the symbol factory, copy operations, and instance comparison. -

- -

- Logic is then defined on top of relay switch logic, as Shannon and others have already done. A machine that requires all inputs to be the '1' symbol to produce a '1' symbol output is a conjunction machine, and so forth. -

- -

- On top of this we can define the Peano Machine, a counter, and then use that machine as the definition of Natural Numbers. -

- -

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

- -

- An axiomatic proof is then a decider that is built up from subroutine calls to the axioms. We might then quantify over all possible compositions of our subroutines in analysis and ask if it is possible that a contradiction decider would return Y or N. -

- -

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

- -

- With the language of Computational Naturalism it is possible to restate every statement ever made by any mathematician; we might say that the mere fact that a mathematician was able to state something qualifies its membership into Zermelo's S set. -

- -

- Given our knowledge that a universal halting problem analyzer that decides if a Turing Machine program halts does not exist, it is desirable to have rules that guide our writing only Turing Machine programs that are known to halt. This can be done through construction, as proposed by Russell, or through axioms of separation, mapping, and choice, as proposed by Zermelo and others. But then we know from the completeness and correctness theorems, that when such guiding rules are applied, there will exist Turing Machine programs that do halt, but whose definition cannot be constructed, nor surmised using the said axioms. -

- -

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

- - - Computational Analysis - -

Definition

- -

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

- -

- In computation theory, computational analysis is defined as the static evaluation of a formal system or machine definition to deduce its absolute boundaries and properties. This process remains entirely distinct from dynamically executing the machine to yield a computed result. -

- -

- This analytical perspective has been present from the very beginning of the field. Alan Turing's formulation of the halting problem relies explicitly on one machine examining another. To properly evaluate the limits of this analytical capacity, the examining machine must necessarily be given definitions of programs that loop infinitely. Consequently, the foundational proofs of computer science formally establish non computational programs as legitimate objects of analytical study. -

- -

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

- -

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

- -

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

- -

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

- -

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

- -

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

- -

- As an analyzer does not run the machine being studied, 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

- -

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

- -

- 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 commands: (step), (step-left), (read), and (write symbol). In the first order, evaluating these commands 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: -

- - - (defparameter *five-ast* - '(progn - (write s) (step) - (write s) (step) - (write s) (step) - (write s) (step) - (write s) (step) - )) - - -

Similarly, the AST for the number 3:

- - - (defparameter *three-ast* - '(progn - (write s) (step) - (write s) (step) - (write s) (step) - )) - - -

- If we were to dynamically evaluate these ASTs in the first order, the 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) command with an inverted pair: a (step-left) command followed by writing the empty symbol (write □). -

- - - (defun invert-direction (cmds) - (cond - ((null cmds) nil) - ( - (and - (cdr cmds) - (equal (first cmds) '(write s)) - (equal (second cmds) '(step))) - (append - '((step-left) (write □)) - (invert-direction (cddr cmds)) - )) - ( - t - (cons - (first cmds) - (invert-direction (cdr cmds)) - )))) - - (defun primitive-compose-subtract (ast-a ast-b) - (let - ( - (body-a (rest ast-a)) - (body-b (rest ast-b)) - ) - `(progn - ,@body-a - ,@(invert-direction body-b) - ))) - - -

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

- - - (defparameter - *primitive-five-minus-3-ast* - (primitive-compose-subtract *five-ast* *three-ast*) - ) - - ;; *primitive-five-minus-3-ast* evaluates to: - ;; '(progn - ;; (write s) (step) - ;; (write s) (step) - ;; (write s) (step) - ;; (write s) (step) - ;; (write s) (step) - ;; (step-left) (write □) - ;; (step-left) (write □) - ;; (step-left) (write □) - ;; ) - - -

- I called this 'primitive' because it is missing the simplification. This sort of simplification is also known as compiler code optimization. Optimizations can be operation specific, or general in nature. Here we will send the primitive composition's body to an analyzer which scans the steps and removes the redundant operations. -

- -

- Because of the purity of the Lisp syntax, we are able to present a remedial simplifier example here. A (step) followed by a (step-left) annihilate each other, resulting in zero net movement of the tape head. Similarly, on an initially empty tape, a (write s) followed immediately by overwriting with the empty symbol (write □) annihilate each other. -

- -

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

- - - (defun remove-annihilations (cmds) - (cond - ((null cmds) nil) - ( - (and - (cdr cmds) - (equal (first cmds) '(step)) - (equal (second cmds) '(step-left))) - (remove-annihilations (cddr cmds))) - ( - (and - (cdr cmds) - (equal (first cmds) '(write s)) - (equal (second cmds) '(write □))) - (remove-annihilations (cddr cmds))) - ( - t - (cons - (first cmds) - (remove-annihilations (cdr cmds)) - )))) - - (defun simplify-machine (ast) - (let* - ( - (cmds (rest ast)) - (reduced (remove-annihilations cmds)) - ) - (if - (equal reduced cmds) - ast - (simplify-machine `(progn ,@reduced)) - ))) - - - -

After giving the difference program to the simplifier, we get:

- - - (defparameter - *simplified-five-minus-3-ast* - (simplify-machine *primitive-five-minus-3-ast*) - ) - - ;; *simplified-five-minus-3-ast* evaluates to: - ;; '(progn - ;; (write s) (step) - ;; (write s) (step)) - - -

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

- -

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

- -

- 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 divide, say 6/0, the machine will not reduce. It will return a second order value: -

- - - (divide 6 0) - - -

Now consider the compiler optimization like simplification of this expression:

- - - (divide (divide 6 0) (divide 3 0)) - - -

The result will be:

- - - (multiply 2 (divide 0 0)) - - -

- There is no special help here. Hence, (divide 0 0) remains as an error flag. -

- -

- The divide machine cannot be run to produce a value, as any value from the field assigned to it would lead to contradictions. Stated more precisely, for x \cdot y = q operations, when given an x and a q value, there is only one possible y value, and it can be recovered with q/x. However, when x is zero, and only when it is zero, q is solely determined by x independent of y, so y is ignored; it could be any value. There is no way to recover it from q/x. -

- -

Evaluating and Extending

- -

- When a machine is 1) programmed to perform a function f, 2) has its tape initialized with a constant input value, say t (which can be a vector of values), and 3) is then run, writing the result f(t) and halting; we say that the run evaluates the function at t. -

- -

- When an evaluator erases the input and leaves only the result in its place, we say it is a substitution evaluator. It is an inconsequential modification to add multiple tapes each with their own tape head to a Turing Machine, so it is possible that an evaluator will have a dedicated tape for the input, a dedicated tape for the output, and have zero or more additional tapes for scratch work. In which case, instead of substitution, one tape is mounted as an input, the machine is run until it halts, and then separately the result tape can be unmounted to potentially be used in a downstream computation. -

- -

- In a variation of analytical evaluation, we can instead mount an initial value for a function, and call a machine to repeatedly extend the function. To state this more precisely, when a machine tape is given the initial value of f(t_i) on its input tape, and then when run until it halts having written the result f(t_{i+1}) to the tape, we say that running the machine extends the function. Typically extension machines are designed so they can be used recurrently to extend the function indefinitely, thus producing a sequence of function values, f(t_0), f(t_1), f(t_2), \ldots. -

- -

- The difference between adjacent function values in the above sequence is called the first finite difference. The forward first difference is defined as: - \Delta_i = f(t_{i+1}) - f(t_i). - While the backwards first difference is - \Delta_i = f(t_i) - f(t_{i-1}). - If 'forward' or 'backwards' is not specified, then the difference is taken to be 'forward'. Hence, extending a function is identical to adding the first difference. Thus a sequence of function values implies a sequence of first differences. -

- -

- A second difference can be defined as the difference between two adjacent first differences. A second difference can be added to a prior first difference to create the next first difference, which could then be added to a prior function value to extend the function to its next value. This pattern can be extended to any number of levels. -

- -

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

- -

- Let us construct a forward difference pyramid for the polynomial f(t) = t^2. -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Count (t)f(t) = t^21st Diff (\Delta^1)2nd Diff (\Delta^2)
0012
1132
2452
397
416
- -

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

- -

- Here is the sequence of tape states as the machine is repeatedly called to extend the function from its initial conditions at t = 0. During each step, the machine adds \Delta^1 to f, and \Delta^2 to \Delta^1, as there is no \Delta^3, it is taken to be zero, so \Delta^2 is merely copied down. -

- - - Initial Tape (t=0): [0, 1, 2] - Call 1 (t=1): [1, 3, 2] - Call 2 (t=2): [4, 5, 2] - Call 3 (t=3): [9, 7, 2] - Call 4 (t=4): [16, 9, 2] - - -

- For Call 1, the input tape is the Initial Tape. In Call 1 the machine will take the function value on the input tape, 0, and add the first difference, 1, writing the result 1, to the result tape. The machine will then continue on and take the first difference on the input tape, 1, and add the second difference on the input tape, 2, writing the result first difference to the result tape, 3. Then finishing up, the machine will not find a third difference on the input tape, so it will copy the second difference found on the input tape as the second difference for the result tape. -

- -

- For Call 2, the input tape is the result tape from Call 1. Execution then proceeds identically to Call 1. This pattern repeats for all successive calls. A person can see the values of t^2 as the first number on each result tape. Any polynomial can be computed in this manner, and the only ALU required is an adder that is also capable of subtraction. -

- -

Lemma: Only row 0 is needed

- -

- The extension function can be called any number of times when the initial tape is identical to row 0 of the table of finite differences. No other row is needed from the table of finite differences. -

- -

- This follows from the mechanical procedure given above for computing the next row of the table from any given row. -

- -

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

- -

- Let the extent refer to the maximum index for accessing a component of a vector; the extent is often denoted as \omega. Performing extensions to calculate the function value at call \omega makes use of the initial tape up to index \omega, or as many nonzero values as are available up to that extent. -

- -

- To make this precise, let us define the difference vector at call k as D_k. The components of this vector are D_{k, 0}, D_{k, 1}, \ldots up to the maximum available difference. The first component, D_{k, 0}, is the function value itself. The component D_{k, 1} is the first difference, and so on. -

- -

- Thus, this lemma claims that to compute D_{\omega, 0}, the highest component index accessed from the initial tape vector D_{0, i} will be i = \omega. -

- -

- Note that to compute the D_{k, 0} result by the mechanical procedure given above requires adding the input tape first difference to the prior difference. That is, D_{k, 0} = D_{k-1, 0} + D_{k-1, 1}. Hence we see immediately the lemma holds for the first call where k = \omega = 1. -

- -

- For an arbitrary k value we discovered that the highest index required of the D_{k-1, i} vector is i=1. - The value D_{k-1, 1} is computed from our mechanical procedure as - D_{k-1, 1} = D_{k-2, 1} + D_{k-2, 2}. Given we already know that to compute the value merely requires the prior value and first difference, we find that the largest index needed from vector D_{k-2, i} is 2. -

- -

- There is a strict linear progression here. The computation of any component D_{k, i} inherently requires D_{k-1, i} and D_{k-1, i+1}. Therefore, each step backwards in time k expands the required index i by exactly one. By induction, computing the base value D_{\omega, 0} at call \omega requires tracing back \omega steps to the initial tape at k=0, which forces the maximum accessed index to be 0 + \omega = \omega. Thus, the highest required component from the initial tape is D_{0, \omega}. -

- -

- The exact algebraic composition of this mechanical expansion is formalized by Newton's calculus of finite differences Isaac Newton formalized this interpolation method in 1675, later published in his Methodus Differentialis (1711). For a comprehensive foundational treatment, see George Boole, A Treatise on the Calculus of Finite Differences (Cambridge: Macmillan and Co., 1860), Chapter II.. Instead of executing the machine incrementally, a person can calculate the function value at call \omega directly as a linear combination of the initial tape components using Newton's forward difference formula: -

- -

- D_{\omega, 0} = \sum_{j=0}^{\omega} \binom{\omega}{j} D_{0, j} -

- -

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

- -

- D_{0, n} = \sum_{k=0}^{n} (-1)^{n-k} \binom{n}{k} D_{k, 0} -

- -

- As a consequence of this lemma, we know that for any finite number of calls, i.e. finite \omega, that a finite prefix of D_0 is used. -

- -

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

- -

- A polynomial of degree \omega is defined by a highest order term a_\omega t^\omega. The first forward difference operator, \Delta f(t) = f(t+1) - f(t), inherently cancels the t^\omega term. The binomial expansion of (t+1)^\omega yields t^\omega as its leading term, which subtracts out, leaving a new polynomial of exactly degree \omega - 1. -

- -

- Taking successive finite differences reduces the degree of the polynomial by exactly one at each step. Consequently, the \omegath difference evaluates to a constant, and the next difference evaluates to exactly zero. -

- -

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

- -

- If an initial difference vector D_0 has an extent of \omega, the sequence of function values generated by the machine corresponds to a polynomial of exactly degree \omega. A person can demonstrate this by algebraically recovering the polynomial constants, a_i, directly from the initial tape components, D_{0, i}. -

- -

- Consider an extent of \omega = 0, forming a polynomial of degree 0, f(t) = a_0. Evaluating at t = 0 yields f(0) = a_0. Because the machine's initial value is D_{0,0}, a person establishes a_0 = D_{0,0}. -

- -

- When a person extends the extent to \omega = 1, the next term is added to form f(t) = a_0 + a_1 t. The first forward difference at t = 0 is D_{0,1} = f(1) - f(0) = (a_0 + a_1) - a_0 = a_1. Therefore, a_1 = D_{0,1}. Note that the addition of the linear term did not change the evaluation at t = 0; the a_0 constant remains firmly anchored to D_{0,0}. -

- -

- Extending to \omega = 2, the polynomial becomes f(t) = a_0 + a_1 t + a_2 t^2. The second difference at t = 0 is calculated as D_{0,2} = f(2) - 2f(1) + f(0). Substituting the polynomial yields D_{0,2} = (a_0 + 2a_1 + 4a_2) - 2(a_0 + a_1 + a_2) + a_0 = 2a_2. Thus, a person recovers a_2 = D_{0,2} / 2. The lower coefficient then adjusts to a_1 = D_{0,1} - a_2. -

- -

- Continuing to \omega = 3, the polynomial is f(t) = a_0 + a_1 t + a_2 t^2 + a_3 t^3. Evaluating the third difference D_{0,3} isolates the highest order term, yielding D_{0,3} = 6a_3. This allows immediate recovery of the highest constant: a_3 = D_{0,3} / 6. -

- -

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

- -

- To observe the structural integrity of this progression, a person can array these relationships into a system of equations mapping the initial tape to the polynomial constants: -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
DifferenceEquation
D_{0,0}= a_0
D_{0,1}= a_1 + a_2 + a_3 + \ldots + a_\omega
D_{0,2}= 2a_2 + 6a_3 + \ldots
D_{0,3}= 6a_3 + \ldots
\ldots\ldots
D_{0,\omega}= \omega! a_\omega
- -

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

- -

- To observe the formal mechanics of this progression, a person can alternatively array these relationships into a matrix equation mapping the polynomial constants, a_i, to the initial tape differences, D_{0,n}. The coefficients of this transformation are defined by the Stirling numbers of the second kind, denoted S(i,n): -

- - - \begin{bmatrix} D_{0,0} \\ D_{0,1} \\ D_{0,2} \\ \vdots \\ D_{0,\omega} \end{bmatrix} = - \begin{bmatrix} - 0! S(0,0) & 0! S(1,0) & 0! S(2,0) & \cdots & 0! S(\omega,0) \\ - 0 & 1! S(1,1) & 1! S(2,1) & \cdots & 1! S(\omega,1) \\ - 0 & 0 & 2! S(2,2) & \cdots & 2! S(\omega,2) \\ - \vdots & \vdots & \vdots & \ddots & \vdots \\ - 0 & 0 & 0 & \cdots & \omega! S(\omega,\omega) - \end{bmatrix} - \begin{bmatrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_\omega \end{bmatrix} - - -

- For any extent \omega, the final row of this strictly upper triangular matrix again simplifies to D_{0,\omega} = \omega! a_\omega. -

- -

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

- -

- a_i = \sum_{n=i}^{\omega} \frac{s(n,i)}{n!} D_{0,n} -

- -

- Thus, extending this procedure \omega times definitively recovers the constants for exactly a polynomial of degree \omega. -

- -

- This mechanical recovery of standard polynomial constants is completely analogous to Newton's interpolation formula Ibid.. Instead of resolving the standard constants a_i through an upper triangular matrix, a person can construct the polynomial directly by treating the initial tape components as the exact coefficients for a basis of binomial terms: -

- -

- f(t) = \sum_{n=0}^{\omega} D_{0, n} \binom{t}{n} -

- -

- Because the nth binomial coefficient expands into a polynomial of exactly degree n, and the summation is bounded by the finite extent \omega where D_{0, \omega} is definitively nonzero, the constructed function f(t) is structurally guaranteed to be a polynomial of degree \omega. -

- -

Difference table for an exponential function

- -

- Here is the table of finite differences for the function 2^t. -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Count (t)f(t) = 2^t1st Diff (\Delta^1)2nd Diff (\Delta^2)3rd Diff (\Delta^3)
01111
12222
2444
388
416
- -

- The first difference of 2^t is also 2^t, so row 0 of the table will have an infinite number of values. Fortunately, due to the lemma stating that evaluating call \omega requires an initial tape populated with components 0 through \omega of row 0, exactly those components are needed for the recurrence to proceed. Furthermore, when new values are needed, they are easily computed. A programmer need not store the entire infinite first row of the difference table on a static tape. -

- -

- Instead of attempting to write an infinite sequence to a physical tape, a person can encapsulate the generation logic within a dedicated Turing Machine. In the tradition of constructive arithmetic associated with Boehm, this generator machine acts as a virtual tape. When the primary extension machine requires the next difference component, it queries the generator machine, which computes and yields the value on demand. This lazy evaluation strategy elegantly handles functions with infinite difference sequences without exhausting finite memory. -

- -

Composition of recurrence functions

- -

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.

- -

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

- -

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

- -

A pole and zero cancellation

- -

- Here we circle back to the division by zero problem, though this time while extending functions. Let us begin with the two functions, f(t) = 2^t - 32 and g(u) = u - 15. Both have D_0 vectors, though the one for the exponential function is defined by a machine rather than by a value on a tape. -

- -

- We cannot do function based arithmetic on these until we synchronize them. Suppose that for each call of the f machine, there will be three calls to the g machine. So we can make a new machine that is called once, each time f is called, g(t) = 3t - 15. -

- -

- Now suppose we want to express the quotient of these two functions. -

- - - h(t) = \frac{f(t)}{g(t)} = \frac{2^t - 32}{3t - 15} - - - Figure singularity plot - - -

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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Count (t)Quotient (f(t)/g(t))1st Diff Ratio (\Delta^1 f(t) / \Delta^1 g(t))
031/151/3
130/122/3
228/94/3
324/68/3
416/316/3
5(divide f(5) g(5))32/3
632/364/3
796/6128/3
8224/9256/3
9480/12512/3
- -

- The quotient machine, (divide f(5) g(5)), is no more representative of the value we expected here, than was (divide 0 0). However, as we have the whole program, we could pass it to a L'Hôpital evaluator and get a value back. But I am wondering if we can't design function extension form that extends to the value and beyond without any hiccups, as most apparently there is a value to extend to. -

- -

- I included the first difference along with the evaluation results in the table above. When building a first difference table an interesting thing happens at the singularity, the first difference and the function itself coincide, note calls 4 and 5. This makes sense because \Delta f(4) = f(5) - f(4), which becomes \Delta f(4) = 0 - f(4), and the same happens to g in the denominator, so the signs cancel. Note also \Delta f(5) = f(6) - f(5), which becomes \Delta f(5) = f(6) - 0. -

- -

Ostensibly it looks like we have happened upon a discrete version of L'Hôpital's rule, that we merely use the first difference quotient instead of the function quotient at the singularity. But alas, the coincidence occurs at h(4) rather than at h(5). For the second coincidence, we find h(6) as the 5th first finite difference. In neither case did we learn anything about the value of h(5). -

- -

- Perhaps if we were performing nonstandard analysis, and extending by increments of epsilon in the domain at each step, the nonstandard analysis naturalization function would find that the differential value can be used as the value at the singularity. But here we are discussing finite differences H. Jerome Keisler, Elementary Calculus: An Infinitesimal Approach, 2nd ed. (Boston: Prindle, Weber and Schmidt, 1986).. We are not doing a local analysis here so as to derive a principle, but rather are trying to evaluate a function in the macro view. -

- -

- So then, perhaps we set the value at the singularity to x build out the difference table, then solve for x? -

- - Figure with x variable. - - -

- As Newton pointed out, we can know the differences on the D_0 row of the table from the quotient function: -

- - - D_{0,n} = \sum_{k=0}^n (-1)^{n-k} \binom{n}{k} \frac{f(k)}{g(k)} - - -

- For k=5 the difference evaluates to be (divide 0 0), as it did for the quotient, and it also fails for all values above k=5 due to the summation. So we can not use this to solve for x. -

- -

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

- - - T = \frac{32 \ln(2)}{3} - - -

The resulting D_0 vector for the quotient is:

- - Figure D_0 h(t) - - Figure D table for h(t) - -

- I find it fascinating to watch the transcendental difference values march down the table, then all cancel out after h(5) is generated. -

- -

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

- - -

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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Count (t)Direct Evaluation (f(t)/g(t))Extended Quotient Vector (H(t))
031/1531/15
130/1230/12
228/928/9
324/624/6
416/316/3
5(divide 0 0)\frac{32 \ln(2)}{3}
632/332/3
796/696/6
8224/9224/9
9480/12480/12
- -

Chapter discussion

- -

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

- - - f(t) = t^3 - - -

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.

- -

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

- -

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 createing 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 \delta out, over the domain of the input. Then instead of back propagation of precision requests at run time, there is a back propagation of precision requirements at analysis time. This approach was used on the AMD K5 processor transcendental microcode to guarantee that computations yielded specified accuracy. The method is also well suited for setting the bus widths for application specific processors, because the analysis step can occur once at design time. Thomas Walker Lynch, A. Ahmed, M. Schulte, T. Callaway, and R. Tisdale, "The K5 Transcendental Functions," Proceedings of the 12th IEEE Symposium on Computer Arithmetic, 1995. DOI: 10.1109/ARITH.1995.465368. Thomas Walker Lynch, "Numerical Analysis of Computer Approximations," September 2018. DOI: 10.13140/RG.2.2.10906.49601. License CC BY 4.0. https://www.researchgate.net/publication/329402329_Numerical_Analysis_of_Computer_Approximations. -

- -

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

- -

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

- -

This section reviewed finite difference methods as a means to implement function extensions. A person should notice that finite differences are one among many methods for extending functions, and they are not always the best choice. In modern computing it is not common to implement function extensions. Rather it is more common to increment a value across a domain, while completely repeating the evaluation for each new domain value, for example when computing values to place on a plot. However, independent of their importance in applied computing, function extension and difference methods are of theoretical importance for analysis, particularly when applied to nonstandard analysis. These speak to the thesis of computational naturalism in the derivation of mathematics, rather than as a proposed method of implementing computational programs. -

- - - Address - - -

Unary Representation address

- -

- A person can define a Turing Machine that is identical to the recursive definition of Natural Numbers as given by Peano. Giuseppe Peano, Arithmetices principia, nova methodo exposita (Turin: Fratres Bocca, 1889). If a person were to run the Natural Number Machine and observe as it writes to the tape, that person would watch as the Natural Numbers are printed one after another: '·s·ss·sss·ssss· ...'. Here '·' represents zero, and 's·' represents one, etc. Because the Natural Number Machine never halts, the machine cannot be used to initialize a tape, but an analyzer can evaluate the machine to make conclusions about what it would write if it were run. -

- -

- In contrast, a function extension version of the Natural Number sequence generator can be run. The function extension machine would be given as input a prior function extension result, or an initial empty tape. It would then modify the tape to contain the next Natural Number, as per the sequence that the Natural Number machine would write, if it could be run. This is accomplished through two subroutine calls: find_empty and increment. The find_empty machine checks the symbol under the head. Upon finding it is not the empty symbol, the machine steps right and checks the next cell, repeating until it finds the empty symbol, whereupon it halts. The increment machine then writes an 's' onto the tape and halts. Recurrent calls to the Natural Number extender then produce a sequence of result tapes: [], [s], [ss], …. Similarly, a programmer can write a machine called decrement, though the programmer must note that decrementing can return the left-of-leftmost symbol. -

- -

- To say that Natural Number A is smaller than Natural Number B is to say that A would occur on the Natural Number Machine tape to the left of B, if the machine were run. Conversely, if B were said to be greater than A, that would mean B occurs further to the right. It is a simple matter for a programmer to write a decider machine for this. The decider is given two input tapes for the two numbers to compare, and it keeps a head on each. It then steps forward until neither head has an 's' under it. If empty symbols are found simultaneously on both tapes, then the two numbers are equal; otherwise, the number with an empty symbol under the head is the lesser number. -

- -

- As such, a person can assign a Natural Number to each cell of a given tape by using a mechanical procedure. Given a machine, say P, and an address machine, say A_P, each time P is stepped right, a call is made to run increment on A_P. Similarly, each time P is stepped left, a call is made to run decrement on A_P. In this manner the tape on A_P will always hold the address that machine P's head is on. -

- -

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

- -

- An address space is a set of addresses for contiguous cells. The tape's address space is the set of addresses for all the cells on the tape. Typically the address of 0 is given to the leftmost among the contiguous cells. -

- - -

Binary Arabic representation address

- -

- Would it be computationally consequential if binary Arabic representation were used instead of unary for addresses? For unary representation each increment was constant time, but with 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? -

- -

- For this discussion, the Arabic representation address is variable precision, so it will grow as the count becomes larger. The empty symbol will serve as the terminator. -

- -

- For Arabic_increment, the machine reads the cell under the head; upon finding a 0 or the terminator, it writes a 1 and halts. Upon finding a 1, it writes a 0, steps right, and repeats the procedure. -

- - - increment: - a = TTU.read() - if a == 0 or a == □: - TTU.write(1) - halt - TTU.write(0) - TTU.step() - goto increment - - -

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.

- -

- Each row shows an input tape, and actions taken to write the result tape. For any given row, the result tape is the same as the input tape on the next row down. The table lists 7 increments, which is sufficient to reach the maximum count that can be held by a 3 bit counter. -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
inputactioncost (steps)
0write 1, halt (result is maximum 1 bit count)2
1 write 0, step, write 1, halt4
01write 1, halt (result is maximum 2 bit count)2
11write 0, step, write 0, step, write 1, halt6
001write 1, halt2
101write 0, step right, write 1, halt4
011write 1, halt (result is maximum 3 bit count)2
111
- -

- The number of programmable controller state transition steps required to reach a maximum 1 bit, 2 bit, and 3 bit count are: [2, 8, 22]. Note these are cumulative. The three bit maximum count cost includes that of the two bit maximum count cost, etc. Each maximum count is exponentially larger, so a better measure is the average cost per step: [2/1, 8/3, 22/7] = [2, 2.667, 3.143] -

- -

- For an n bit counter, the sequence of costs follows a pattern. Half of the increments evaluate one bit (costing 2 steps), a quarter evaluate two bits (costing 4 steps), an eighth evaluate three bits (costing 6 steps), and so forth, over the 2^n - 1 increments required to reach the maximum n bit count: -

- - \sum_{k=1}^{n} 2k \cdot 2^{n-k} = 2^{n+2} - 2n - 4 - -

- To find the average cost per increment to reach each maximum, an analyst divides by the total number of increments, which is 2^n - 1: -

- - \text{Average Cost} = \frac{2^{n+2} - 2n - 4}{2^n - 1} = \frac{4(2^n-1)+4-2n-4}{2^n-1} - -

- This simplifies algebraically to: -

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

- -

- Consequently, maintaining an 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 model used here to define an address is analogous to keeping a pointer into memory. Each step then increments or decrements the pointer. Conventional processors do the converse of the Turing Machine model presented here. For a processor, the address is the base object, while the head location is what is implied by the address. On processors, pointers will be one word in width. In small geometries where computation element delay dominates, two operand adders tend towards logarithmic complexity evaluation times against bit width, and the constants are small. Because of this, it is practical to perform word width addition operations atomically in one machine cycle. In fact, for some machines, the adder time likely sets the clock period. Such an adder will be used for address arithmetic; consequently, a programmer cannot arrange a program to expose aliasing in the address increment time to the real world. It remains a theoretical observation. -

- -

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

- -

- Direct address decoding operates independently of reference locality. This fundamentally differs from a Turing Machine head, which incurs a linear computation cost strictly proportional to the distance traveled. However, direct decoding is only the base of the memory hierarchy. -

- -

- It is possible that decoding occurs separately in a row and column manner, and changes in the lower bits of the address walk a buffered row that was found in a prior access. This makes access to neighbor cell addresses within a row a low expense operation. However, this depends on memory implementation. One layer up, it is common for memory to be made of interleaved banks, so neighbor access that remains in the leaf collection is generally faster than that which requires fetching a new leaf set. -

- -

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

- -

- Memory accesses into the processor local memory file are even faster. If locality of reference, even in an abstract sense, remains tight, then memory cells can be accessed in a minimal amount of time. -

- -

- For programs with large memory footprints and sparse memory access patterns, the dominant factor becomes the virtual memory subsystem. Here locality again comes into play as the translation lookaside buffer provides stateful location context, and the neighbor relationship between pages is sometimes taken into account for performance reasons. However, once a program starts performing at virtual memory page fetch times instead of cache access, or even local system memory access times, the program is said to be page thrashing, and it becomes very slow. It is also possible for small programs to have memory access patterns that alias against the memory subsystem's heuristics and lead to page thrashing. For a typical system, a programmer can write a small program to demonstrate this. -

- -

- In summary then, using 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. -

- -

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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Memory TierReal World LatencyScaled DelayScaled Arrival EraHistorical Context
L1 Cache Hit1 ns3 days-0043-03-18Three days after the assassination.
DRAM (Main memory)100 ns300 days-0042-01-09Nearly a year later, during the Liberators' civil war.
NVMe SSD Page Swap15 µs45,000 days0080123 years later, exactly as the Colosseum is completed in Rome.
SATA SSD Page Swap100 µs300,000 days0778821 years later, during the reign of Charlemagne and the Frankish Empire.
Magnetic HDD Page Swap10 ms30,000,000 days82092Tens of thousands of years in the future, long after current human civilizations are dust.
- -

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

- - - Area and partitioning - -

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

- -

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

- -

Head partition

- -
    -
  1. The left side: The finite set containing all of the cells to the left of the head cell.
    2. -
  2. Head: the head cell.
    3. -
  3. The right side: the infinite set containing all the cells to the right of the head.
    4. -
- -

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

- -

Leftmost/remaining partition

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

Active area partition

- -

- A nonempty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: -

- -
    -
  1. The left empty tail: if the leftmost cell of the tape is an alphabet cell, there is no left empty tail. Otherwise, it consists of the leftmost cell and the empty cells, if any, to the right of the leftmost cell, up to, but not including, the first alphabet cell.
    2. - -
  2. Active area: a finite area for computational problems, containing the cells extending from the leftmost alphabet cell up to and including the rightmost alphabet cell. It is possible that the leftmost alphabet cell and the rightmost alphabet cell will be the same cell.
    3. - -
  3. The right empty tail: the infinite set extending from the right neighbor of the rightmost cell of the active area, extending rightward.
    4. -
- -

- A noncomputational tape is one that cannot be initialized by a Turing Machine, but can still be surmised to exist, perhaps in analysis due to its properties. The empty tape is an example. The tape holding the Natural Numbers is another example. For noncomputational tapes that have the property that the active area is open on the right, there is no right empty tail. -

- -

Area implied partition

- -

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

- -

The impossibility of recognizing an empty tape

- -

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

- -

- The active area partition of a tape only works for tapes that have at least one alphabet cell. As soon as a machine does its first write of an alphabet symbol, it is known the tape has at least one alphabet symbol. However, what if a tape of unknown status, whether completely empty or containing an alphabet cell, is mounted on a tape machine, and it is desired that the machine recognize if the tape is empty or has an alphabet cell? This is the equivalent problem of looking for the leftmost cell of an active area. -

- -

- Recognizing that a tape is empty is generally impossible. Suppose it were attempted, and a machine started scanning the tape rightward from the leftmost cell; for every cell that is discovered to be empty, the machine would have to scan further rightward to check for an alphabet cell. If the tape is truly empty, the recognizer would never stop scanning, so no decision would ever be rendered. -

- -

The impossibility of recognizing the rightmost cell of the active area

- -

- In general, a Turing Machine cannot step across a tape reading cells to recognize the rightmost cell of the active area, or equivalently, the leftmost cell of the right empty tail. Suppose a recognizer attempted this by starting in the active area and stepping right, and the machine discovered an empty cell. The machine would be unable to distinguish between the case of said empty cell being embedded within the active area (meaning more alphabet cells lie further to the right), or the case where said cell is genuinely the leftmost cell of the right tail. To resolve the ambiguity, the machine would be obligated to continue stepping right. Yet, there would never come a time where finding another empty cell would avoid leading back to the exact same case ambiguity, so the machine would forever step right without returning a decision. -

- -

- It follows that if knowledge of the end of the active area is needed, this information must be encoded as a message. For example, a special symbol can be reserved in the alphabet specifically to serve as the end of active area marker. Each time a machine steps beyond the current end of active area marker and does a write, it writes the marker in the right neighbor cell, and goes back and erases the old mark. This method is related to communications theory and the science of signaling. Here, the active area marker is an out of band control signal. -

- -

- If a tape is written by an initializing tape machine, unmounted, and then mounted on a second analyzing tape machine, the analyzing tape machine is starting with a populated tape. Similarly, a mathematician can, by decree, define an initial tape that holds predefined alphabet symbols. In such a scenario, the initializing machine and the analyzing machine must use a shared communication protocol for signaling the end of the active area. They cannot operate independently or the analyzing machine would not be able to find the end of the active area. This shared protocol then represents information held by a mediator, said mediator could be used at a higher level to write the control for the two machines, or it could be consulted when the two machines are run. Hence, the mediator is either an author, or a service provider, or possibly both. -

- -

- By definition, a computation must finish in a finite number of steps. It follows that the active area when a Turing Machine halts a computation will always be finite. Consequently, if a Turing Machine initially starts working with a tape that was computed by another Turing Machine, the length of the input will be finite. Still, that input will be in the active area, so the receiving Turing Machine will need to read control data left on the tape under a common communication protocol to be able to find the bounds of the input area. -

- -

- When an input tape is provided as a general mathematical object, either decreed by definition or perhaps abstracted from 'what a Turing Machine computation would produce in the limit of step count', then the input can be either finite or infinite. -

- -

In band and out of band control

- -

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

- -

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

- -

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

- -

Virtual cells

- -

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

- -

Now imagine we define a Turing Machine such that when it steps right, it steps to the right neighbor area, and when it steps left, if there is a left area, it steps to that, otherwise it returns a left-of-leftmost symbol. The read instruction reads all of the cells in the area, and similarly the write instruction writes them all. Then for this machine the areas are virtual tape cells. -

- -

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

- -

Virtual tape

- -

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

- -

Various portions of this text have mentioned calling a Turing Machine as a subroutine. This is described as unmounting the tape from the calling machine, mounting it on the subroutine machine, running the subroutine machine until it halts, then unmounting the tape from the subroutine machine, and mounting it back on the calling machine. However, this would be a manual process. To automate the process, we use a Universal Turing Machine. It has the definition for the calling machine and the subroutine machine on its tape. We can add an additional tape to the machine to hold the stack. Then a subroutine call happens much as it does in conventional software. -

- -

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

- -

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

- -

Now suppose defining a Turing Machine that initially has the head on the leftmost cell of a specific area. When step left is called, the tape transport immediately returns the left of leftmost symbol, independent of whether the area is actually at the physical left end of the tape or not. -

- -

-Now suppose defining a Turing Machine that initially has the head on the leftmost cell of a specific area. When step left is called, the tape transport immediately returns the left of leftmost symbol, independent of whether the area is actually at the physical left end of the tape or not. -

- -

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

- -

Partitions on a finite virtual tape

- -

- When a Turing Machine operates on a finite virtual tape, the structural logic of the partitions established earlier must be updated to reflect the absolute rightward boundary. -

- -
    -
  1. For the Head partition and Area implied partition, the right side is no longer infinite. It is a finite set containing all cells extending from the right neighbor of the head (or area) up to the absolute rightmost cell of the virtual tape. If the head (or area) includes the rightmost cell of the virtual tape, the right side set does not exist.
    2. -
  2. For the Leftmost/remaining partition, the remaining area is now a finite set terminating at the rightmost cell of the virtual tape.
    3. -
  3. For the Active area partition, the right empty tail is similarly a finite set extending to the rightmost boundary of the virtual tape. If the rightmost alphabet cell occupies the rightmost cell of the virtual tape, the right empty tail does not exist.
    4. -
- - Metrics - -

Address defined area

- -

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

- -

- When cells were defined we noted that they were sets, and that these sets had identity and could be referred to. We needed that to be the case so as to build the tape topology using neighbor properties. Had the tape been singly linked, perhaps we could have used the cells to represent themselves in the properties, but when we doubly linked it, a given cell had to appear in two places, as the right neighbor of its left neighbor, and the left neighbor of its right neighbor, so we stipulated the sets as being identifiable. Initially we did not say how they would be identified. This is common in mathematics, but we soon cleared this up by formalizing the concept of a symbol. -

- -

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

- -

- So we now have two means for identifying a feature. One means is to state its address, and the other is to put a tape machine head on it. -

- -

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

- -

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

- -

Distance and extent

- -

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

- -

In an analogous manner to defining an address space for a tape, we can define an address space for an area. Accordingly, the leftmost cell of the area is assigned address zero, and the address increments cell by cell going to the right. A finite area will have a finite address space, with the address of the rightmost cell being the largest address in the address space. -

- -

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

- -

Length

- -

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

- -

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

- -

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

- -

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

- -

How cardinality is computed

- -
    -
  1. We set Turing Machine P with its head on the leftmost cell of an area. We mount the initial tape, '·', on the A machine.
    2. -
  2. We step P and simultaneously run the A machine. Stepping stops when P reaches the rightmost cell of the area. At this point, the tape on the A machine holds the address space extent.
    3. -
  3. The A machine is run an additional time. The output on the tape is defined to be the cardinality of the address space, aka the cardinality.
    4. -
- -

Lemma 1, the A machine produces Natural Numbers

- -

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

- -

Lemma 2, cardinality is a natural number

- -

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

- -

Lemma 3, cardinality is not in the address space

- -

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

- -

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

- -

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

- -

The apparent contradiction.

- -

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

- -

Resolution

- -

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

- -

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

- -

What if extent was used instead of cardinality?

- -

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

- -

- Now here is an interesting result: -

- - - \aleph_{0} - \aleph_{-1} = 1 - - -

- Neither machine can be run. However we can compose the two machines, then simplify the composition. When we do so, the ever larger Natural Number machines annihilate each other, and the increment machine remains. The increment machine can be run, so we end up with an output value. -

- - -

Size

- -

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

- - Multiple machines and sharing tapes - -

Suppose we unmount a tape from a halted Turing Machine, say machine T0, and then mount the tape on another Turing Machine as input, say machine T1. Suppose we do this so that machine T1 may calculate the length of the output made by the first machine. When we do this, we run into some problems.

- -

Firstly, for a conventional Turing Machine, the tape that is mounted on T1 will be infinite, so no computational T1 machine will be able to process it unless there is a message on the tape telling T1 where the end of the input is. For our TTCA machines, if T0 starts with a null tape, and then expands it, and T0 is computational, then at the time T0 halts, the tape will be finite. T1 can then use the continuation of stepping beyond rightmost to know that it has processed all of its input.

- -

If a Turing Machine does nothing then halts, it will implement an identity relationship between input and output. If we do not want the input given to a machine to 'bleed through', we will have to erase it. A computational TTCA Machine starting from a null tape can only produce finite tapes, so T1 can erase whatever T0 writes to the tape. However, if we are analyzing, instead of running the TTCA machine, we might discover that the tape length would be infinite if the machine could be run. We know that if we pass an infinite tape to a computational TTCA, it would not be able to erase the tape. Fortunately we can derive this fact through analysis and proof without having to run the computational machine to see if it erased the tape.

- -

Hence if we allow for infinite inputs, we should add an 'erase-to-end-of-tape' command to our machines, so that the computational machines may leave a tape with only their outputs on them. Our erase-to-end-of-tape command will be executed in a single step.

- -

Once an input tape is mounted, T0 is a computational TTCA machine given a finite tape, its output is a finite tape, and that is taken to be the input for T1.

- -

T0 is required to provide meta information about the length of the active area. This approach is known as in-band signaling. Because length information is mixed with the data.

- -

T0 updates a dedicated table where it keeps track of the location of data objects and their lengths. Such a table is called a symbol table, and such a system is called a type system. This is written to a separate tape, or it is inserted at a known location on the main tape. In the case it is written to the front of the tape, the data following will have to be moved when the table grows. In the case it is written at the end of the tape, the table will have to be moved when the data grows. In either case the symbol table entry lengths themselves must also be managed, typically they are either coded into the controller or make use of in band signaling. It is conceivable that a symbol table would describe itself.

- -

We adopt a convention of maintaining a compact tape. As such we have no embedded empty-symbols in the active area. Then the empty-symbol marks the end of the active area.

- -

Each machine has two tapes, an input tape, and an output tape.

- -

A compact area is one that has only alphabet symbols (no empty-symbols). We can extend this concept to say that the density of an area is the ratio of alphabet symbols to empty-symbols.

- -

The approach we use in modern computing is often the 3nd one listed above, that of the type system. We carefully account for the length of each instance of data. Then we build up each larger instance from smaller ones, and while doing so, we add the lengths of the smaller instances to calculate the length of the larger instance. All programs then specify when they make or compose instances and their types.

- -

A system for creating the appearance of many tapes over a single tape is called a memory manager or a memory allocation system. It is typically better to use one of these and multiple tape models rather than solving the problem of moving objects around in memory in an ad hoc manner.

- -

Here is an important question for the TTCA model: is it possible to define a memory manager that creates the appearance of multiple expanding tapes over the top of a single expandable tape? This problem is solved for managing files on a hard disk. However, all current file systems break at some point when pumped. So the question being asked here is equivalent to asking if a files system can be made without such architectural limits. The answer to this is yes, it is possible, as we will see in a later chapter of this book.

- -

Hence there are multiple conventions we may use for implementing the abstraction of multiple tapes on a tape machine. Multiple tape machine are equivalent in power to one tape machines, but sometimes they are easier to think about.

- -

Now as we have multiple tapes it is fairly easy to show that having multiple tape machines is equivalent to having one machine. We first view the multiple tapes worked on by the multiple machines as the multiple tapes of one machine. We then compose the state controllers in series, where the halt state of one is the initial state of the next one. Thus we may also conclude that having multiple tape machines is not more expressive than having one tape machine. We may also look at our multiple composed state controllers as one multiplexed controller, and then conclude that having multiple machines will not have an order of speed or space usage advantage.

- -

The advantage of having multiple tape machines each perhaps having multiple tapes is that sometimes it is easier to think about. It is a method of partitioning the problem.

- -

Suppose our machines have two tapes where one is called the input tape, and the other tape the output tape. Our procedure for passing tapes between machines will consist of umounting the tape from the source machine, then taking that tape over to the destination machine and mounting it as the input tape.

- - -

Abstract areas and partitions

- -

- A tape area and partitioning can be an abstraction defined by a function rather than merely by a leftmost and rightmost cell. Such areas can have different topologies than those of the base tape. A familiar example for most computer scientists is utilizing software to create the appearance of a two dimensional array over a linear memory. -

- -

- Accordingly, suppose there is a three tape Universal Turing Machine gasket machine that holds the definition of a base machine on a first tape. It calls the base machine as a subroutine to access the base machine's tape (the second tape), and it uses its own tape to organize the tape abstraction. Then this outer machine can present to its user a variety of transforms of the base machine's tape. -

- -

- As an example, a gasket machine could partition the base machine's tape into two areas, one consisting of the odd addressed cells, and the other of the even addressed cells. Though these two areas consist of noncontiguous cells on the base tape, when viewed through the gasket machine, they appear perfectly contiguous. In this case, each area will have a leftmost cell and remain open on the right. -

- -

- When the base machine tape cells behind an abstract area are physically contiguous, we say that the abstract area is compact. In the odd even tape partition example, the abstract areas lack compactness. -

- - Zero length is a second order concept - -

Suppose we have a Turing Machine that is designed to mark an area based on some property of the symbols.

- -

Suppose further that starting with the head on the first cell, our Turing Machine will step right zero or more times until it finds a cell that holds a symbol that has the special property.

- -

Once it finds such a cell it will write an area marker symbol to that cell, step right, and repeat writing area marker cells until it finds a cell that holds a symbol that lacks the area property. At which point the machine halts.

- -

Once an area is marked, we can go back and run a length measuring machine that counts the sequence of marks.

- -

However we have a couple of problems, if there is no cell on the tape that has the special property. The area marking machine will step right without halting while looking for the marker. As a second problem, if the all the cells to right of the leftmost area cell, the area marker machine will never halt. -

- - - -

Now suppose we employ a second order analysis.

- -

Instead of running our area marker Turing Machine, we examine its definition and the definition of the machine that generated the tape data, to learn if such a machine will ever halt.

- -

Although we know that it is not possible in general to analyze machines to know if they will halt, or not, it is certainly possible to do so in some cases, and this is one of those cases.

- -

Upon analysis of our area marking machine we make a startling discovery: inputs exist for which the area marker will never halt.

- -

In one case, if there is no leftmost symbol with the property that defines the area we are looking for, the marker machine will search forever.

- -

In the second case, once the area is found, it is open on the right and it never ends.

- -

We might say that inputs that have no leftmost symbol have an area of zero length.

- -

This is an abstract concept, because our area marking and area measuring machines will never be run then halt and return a length measure of zero.

- -

Instead we might arrive at this conclusion that a non-existent area has zero length through inductive reasoning: Say we have an area of length i, and then remove one element from the area, then it has length i-1.

- -

As we repeat this, then eventually we will have an area of length 1 as discovered by our length assigning machine. Now we remove 1 more element.

- -

Each time we removed an element before, it made the length smaller by 1, so we reason that 1-1 = 0. The area is now length zero.

- -

We cannot go any further because there are no more elements to be removed.

- -

In this case we arbitrarily imagined a longer area. No such longer area was stated in the problem formulation.

- -

In real world programming, this is the difference between having a container that by implication will hold elements, and lacking the container entirely.

- -

By applying the limit logic, we have implied that an area exists.

- -

If running the area maker machine is asserting the existence of such an area, then it makes sense to speak of a zero length area.

- -

However, if we are not making this assertion, then there is no area so the issue of length is irrelevant. This is a nuanced problem.

- -

Note, then, that zero length is a second order concept. We cannot mark nor measure it, and given our first order definition for an area, nor can we even represent such an area at a first order.

- -

There must be some external structure present that implies the existence of the area for zero length to even make sense.

- -

This insight explains a lot of the pain related to the processing of end cases in computing. It will come up again in this volume when we examine the question of the emptiness of containers, see the section .

- -

It also explains why loops so often need to be primed or given special case guards, which operates identically to adding a layer of analysis. We will discuss this further later when introducing the first-rest pattern see, .

- -

It is interesting that non-existence has collided with zero length. This seems to be a contradiction, as something that does not exist should not have any length at all.

- -

All of this happens at the second order, at the order of analysis. At this order we can make a distinction between an area that we have given a name to, and perhaps a location, as compared to an area for which we have done neither of these things.

- -

Thus for purposes of second order analysis we will say that an area exists if it has a name or a location, even if it has zero length.

- -

We will say an area does not exist if it has neither a name or a location. Again, execution of our first order area marking and length machines cannot provide us with any such information.

- -

Need for the concept of cell

- -

Let us ask a question, what is it that an address is actually locating? Let us consider this question in the light of an example. Suppose we have the tape sequence of:

- - - a, b , c, ε, ε, ε … - - -

Now consider that we have an address of '2'. If we read tape address 2 we get back the letter 'c'. So the address is locating the 'c'. Now suppose we write at address 2. Say we write 'γ'. Now our sequence is:

- - - a, b , γ, ε, ε, ε … - - -

Now we write 'Г', resulting in the sequence:

- - - a, b , Г, ε, ε, ε … - - -

It would appear that the answer to our question is that address 2 is locating different things at different times. First it was, c, then γ, then Г. Yet the address did not change. It feels a little unsatisfactory to suggest that our concept of location depends on the value addressed. Also, notice, that when we made the Natural Number Turing Machine, that the values on the tape that was placed into correspondence with the Natural Numbers were never mentioned. Yet, we can't seem to answer the question of 'what is being addressed' without giving a value.

- -

Addresses speak to the structure of the tape rather than the values held on the tape. So as to facilitate this interpretation, we note that a sequence consists of a sequence of cells holding elements, rather than being simply a sequence of elements. Given the concept of a cell we can say that an address always locates the same cell, though the contents of that cell can change.

- -

This operates similarly to a small extension to the already existing concept of a variable in mathematics. In mathematics we allow that a variable can take on different values, though its name never changes. Now we are going to say that a cell can take on different values, though its address never changes. Furthermore, as the cell is part of the sequence, we are going to say the cell itself has a left neighbor or right neighbor, excluding the value in the cell.

- -

Address of an area

- -

The address of a cell is the number of steps required to reach the cell when starting from the leftmost cell on the tape. The leftmost cell has an address of zero. It might seem intuitive to set the address of an area on the tape to be that of the first cell in the area. If we require that an area have at least one cell to exist, this approach works even for machines with a cell delete command.

- -

Suppose that we are deleting the cells in an area. The delete command affects the cell to the right of the cell the head is on. Hence to delete all the cells of an area, the head is placed on the left neighbor cell to the area. Say that we delete an area of three cells. We will call delete three times. It seems unsatisfactory to say the area no longer exists after the three deletes because the head locating the area never moved. I.e. we still have a location marker for the area, so we could, for example, call append and put a cell back into the area. For the area to truly not exist, it would not have a location.

- -

Thus it seems more satisfactory to locate an area by its left neighbor cell, than to locate it by its leftmost cell.

- -

The inverse case also suggests that the cell to the left of an area defines its address. I.e. if we call append to grow an area, it grows to the right of the cell the head is on. According to this definition of area location, the rightmost cell locates a currently zero length right tail of the tape that will potentially be grown.

- -

In a sense what we are doing while exploring the meaning of area, existence, and zero length with these delete and append examples is performing a discrete limit in analogy to a limiting operation in calculous. To support having such a limit operation, the location of an area is that of the left neighbor of the leftmost cell in the area.

- -

Not all is satisfactory. When using the left neighbor of an area as the location for an area, we cannot locate an area that starts on the leftmost cell of the tape. If we make this a special case, then we have failed to make a first order definition for area, because the special case information will have to be stored in a higher level structure that describes attributes of the tape.

- -

Nor can this use the left cell approach work in the case of multiple areas.

- -

Suppose we have two adjacent areas.

- -
- Tape with two areas -
Figure 2 Tape with two areas
-
- -

Here we show a first area, say a0, that includes cells 7, 8 and 9. And a second area, say a1, that includes cells 10, 11, and 12. Thus, by the convention of using the address of the cell to the left of an area as the area’s address, a0 has an address of 6, while area a1 has an address of 9. Because the areas are adjacent, the address of area a1 is the same as the address of the rightmost cell in area a0.

- -

We know that area a0 is located to the left of area a1 because a0's address is less than a1's. I.e. 6 < 9.

- -

Suppose we delete cell 10. Though cell 10 is gone, our addresses remain consecutive, so what was cell 11, is now called cell 10, etc. and the diagram appears much as before, though area a1 is now only 2 in length:

- -
- Step by step area two becomes shorter -
Figure 3 Step by step area two becomes shorter
-
- -

Now we delete the cell at address 10 two more times, and all the area a1 is gone. During the deletion, and just after, the head will be on the rightmost cell of area a0, i.e. on cell 9. We can now say we have an area of zero length located at cell 9.

- -
- Second area goes to zero length -
Figure 4 Second area goes to zero length
-
- -

Now suppose after deleting the area a1, as just described, we continue on to delete area a0. Each time we delete the leftmost cell of a1 the rest of area a1 moves left by one. Hence, after the first deletion the address for empty area a1 becomes 8. Area a0 is still located to the left of a1, because 6 < 8:

- -
- Limit towards zero length being applied to the first area -
Figure 5 Limit towards zero length being applied to the first area
-
- -

Finally when all cells in area a0 have been deleted, a1 has collapsed into a0. Both have the address of 6, so the order between them can no longer be derived from looking at the base addresses. Should we attempt to reverse the steps above, and only be given the machine at its final state we would have to begin by guessing what the order was between the two areas, a0 and a1.

- -

So again, there is either missing information, or some information is not stored on the tape we are discussing.

- -

As yet another problem case that is either not possible or requires external information, if an area includes the leftmost cell of the tape, then its location cannot be described with an address.

- -

Hence this approach of using a discrete analogy to limits has led to some unsatisfactory end cases. We will visit this subject of areas on tape in the section, Area as a mapped tape and present a higher order approach for defining area location that avoids such end cases.

- -
- - -
- - Some properties of Turing Machines - -

For a given Turing Machine, the input is the sole determiner of the output. I.e. each time the same input is given, we get the same output. The input and output are mathematical objects, hence Turing Machines are functions. However, it is common in computer science to speak of Turing Machines as 'solving problems' rather than saying they are functions. This is because we often think of the inputs and outputs of Turing Machines as being something other than mathematical objects. For example, when a Turing Machine sorts sequences found on its input, we might say that it solves a sorting problem.

- -

Turing Machines will differ due to differing alphabets, state controller graphs, associated commands, start, and halt states. The choice of empty-symbol is inconsequential as long as it is distinct from the alphabet. As we will see in the later discussion on variations, the choice of alphabet is not very important. For two alphabets of the same cardinality we can setup a one to one mapping, and for those of differing cardinalities we can use sequences of alphabet symbols that map to alphabet symbols. For example, given an alphabet of ‘T’ and ‘F’, and a second alphabet of ’t’, ‘f’, ‘x’, ‘z’ we may make the following map:

- - - f - | FF - - t - | FT - - x - | TF - - z - | FF - - -

Then given this mapping, we may use two cells for each one cell for any {‘f’, ‘t’, ‘x’, ‘z’} alphabet machine, and then use the only the {‘T’, ‘F’} alphabet.

- -

There are a countably infinite number of permutations for alphabets, state controller graphs, associated commands, start and halt states, hence there are a countably infinite number of Turing Machines that fit our definition. However, there are an uncountably infinite number of mathematical functions. Consequently, we must expect that some functions cannot be computed with Turing Machines.

- -

There might be multiple Turing Machines that perform the same function. A set of such machines forms a functional equivalence class. Within a functional class there will be a class of members related in that they all use the smallest number of steps when considered against the limit of input length. We discuss this further in the section on complexity.

- -

Of special importance to computation theory is the existence among all these infinite Turing Machines of a class of machines that read their state controller definition from the tape as an input. This is the Universal Turing Machine class.

- -
- - Performance Analysis - -

An interesting aspect of the Turing Machine procedure is that it introduces the concept of stepping the machine. With the addition of some simple constraints it becomes possible to map the parts of the Turing Machine abstraction to the parts of some real machines. These constraints may take the form of such things as bounds on the length of the inputs, or the addition of out-of-resource errors. Because such constraints do not affect the 'normal' workings of the machine, the derived relationship between a Turing Machine step, and that of a unit of real time might not be that complicated. Indeed, except for some enumerable cases this relationship might even be so simple as to assign to a step an approximately constant amount of time.

- -

Because of the existence of a relationship between steps and time, particularly when it is a simple one, it is very interesting for us to know how many steps a Turing Machine will take.

- -

There are many ways to measure the complexity of a Turing Machine. Among these is something called the time complexity, which is a function that relates the length of the input to the number of steps required to reach the halt state.

- -

To derive time complexity we typically start with a step count formula which maps the length of Turing Machine input to the worst case largest number of steps. We then consider the behavior of this formula as input length goes towards infinity. To get this, we take the highest order term from the step count formula. Conventional results are constant time, polynomial time, or exponential time.

- -

We can derive the 'worst case length of the area written or read by the machine during computation' function in an analogous manner as for the step count function. This function is known as the space complexity. We may also consider the limiting behavior of this function to derive an order of space complexity.

- -

The order of time or space complexity will remain the same against certain variations of our Turing Machine definition. For example, if we double all the states by adding a second state that we always visit, where this second state does nothing, the number of steps would double but the functionality would not change. Order of complexity also would not change. A fixed time machine before doubling up on the states would still be a fixed time machine afterward. It is simply that the number of steps would be twice as large, but still a fixed number relative to the size of the input. A polynomial time machine would still be polynomial time, simply with double size constants. We say that changes which do not change order of complexity, nor existence proofs, are inconsequential.

- -

Suppose we have a complete Turing Machine functionality class. We say that it is complete because all possible machines for implementing the function are in this class. Some machines in this class will have a different order of time complexity than others. Now we consider the set of minimum order of time complexity machines from this class. As the larger set was complete, the set built against this constraint will also be complete relative to the constraint. We then say that this minimum order of time complexity is a property of the problem being solved, rather than being a property of a particular machine.

- -
- - Conventional Turing Machine variations - -

In the first section of this chapter we gave a rather conventional definition for a Turing Machine. In the prior section, Complexity, we noted that we can analyze Turing Machines to find their time and space complexities. In this section we will discuss some variations that a person finds in the literature.

- -

A variation on the conventional Turing Machine definition is allowed when it can be proven that the variation never causes existence, order of time complexity, nor order of space complexity results to change, and in this respect is inconsequential. Earlier we gave the example of doubling up the states as being such a variation, though that is an excluded variation typically.

- -

Open in both directions tapes

- -

Some Turing Machine descriptions describe a tape with no end in either the left or right directions, i.e. a tape that is open in both directions.

- -

This feature adds no richness of expression, because we can get the same behavior from a Turing Machine with a single ended tape. To do this we partition the single ended tape into odd addressed cells and even addressed cells. The odd cells are said to be the right side of the tape, and the even ones the left side. We then rewrite any tape controller based on a bidirectional tape to instead use the 'odd' and 'even' channels instead of the left and right sides of the tape.

- -

This same approach form can be used to show that multiple tapes, or even multi-dimensional tapes, add no expressive power. The good news is that such variations can be used whenever convenient, and we will get the same results.

- -

Going in the other direction, the open in both directions tape is not a simplification. There is still a start cell, being the cell that the head is initially placed on. And as noted above, the topology around this start cell is no different, it is simply a question of the adjectives we use for describing it.

- -

Alphabet replacement

- -

Without loss of generality, we may replace the alphabet with a single symbol, say 's' (short for successor). This is because symbols in any alphabet can be placed into correspondence with a sequences of 's' symbols. For example, the symbols of the alphabet of {w, x, y, z} can be placed into one to one correspondence with the sequences in the manner of {<w, s>, <x, ss>, <y, sss>, <z, ssss>}. We will need to put the empty-symbol between any such sequences on the tape, so that two sequences can be distinguished from one longer sequence.

- -

Alternatively we can adopt a two symbol alphabet instead of a single symbol, where the second alphabet symbol is an end of sequence marker.

- -

In contemporary computing we use an alphabet of two symbols, {0, 1}, and fixed length sequences. No end marker is needed when the sequences to be placed into correspondence are of fixed length. So for example, the symbols in the alphabet {dog, cat, mouse, fish} may have the correspondence of {<dog, 00>, <cat, 01>, <mouse, 10>, <fish 11>}. Conventional fixed sequence lengths are 8, 16, 32, and 64. So for example, when the sequence length is 8, any alphabet of 256 symbols or less may be placed into correspondence. A conventional correspondence table is that of the ASCII code.

- -

The fixed length to be used can depend on computational context. (In contrast, UTF8 does not use fixed length sequences, so there must exist at least one end of sequence marker.)

- -

Another alternative to end of sequence markers for variable length sequences is to externally account for sequences lengths. We call such an accounting system a type system.

- -

Leaving out the empty-symbol

- -

When we use a fixed sequence of {1, 0} to stand for symbols, it is expensive to reserve a sequence for the empty-symbol. This expense is due both to losing the use of a symbol in the alphabet, and in the complexity of control circuitry when keeping track of it.

- -

The empty-symbol functions as a property of the machine rather than simply another alphabet member, because the tape initially has an infinite tail of empty-symbols. A computational Turing Machine is limited to taking a finite number of steps. Thus it cannot compute a tape initialized with an empty-symbol (or any other value).

- -

However we can add a constraint on all Turing Machine controllers that requires of controllers that they never write the empty-symbol, and always write an alphabet symbol to a cell before reading it. Then, because a cell is never read before being written, it does not matter what we write into it for initialization. We may even use an alphabet symbol. Consequently this constraint allows us to eliminate the empty-symbol. This gives us the following Turing Machine variation:

- - - 1. fixed finite alphabet - 2. fixed write before read constraint - 3. variable single ended tape - 4. variable read/write head - 5. variable read value buffer - 6. fixed controlling state machine - 7. fixed left from leftmost error - 8. fixed start state - 9. fixed halt state - 10. variable current state - 11. fixed procedure for using these. - - -

To validate that this is an inconsequential Turing Machine variation, rather than a description of new abstraction that is not a Turing Machine, we must show two things: Firstly, that any of the now disallowed controllers never compute something that cannot be computed in the presence of the constraint. And secondly, that there are same complexity class alternatives for any disallowed controller.

- -

No need to step into the inactive area

- -

1. When attempting to step into the inactive area, instead keep a counter for the number of steps the machine would take. Only allow reads or writes or head movement when the counter is no longer needed due to the head having moved back into the active area.

- -

2. Write an alphabet character and change the inactive area traversed into an active area.

- -

The TTCA Turing Machine variation

- -

The active area on the tape can grow at most by one unit for each machine step. This largest growth occurs when the Turing Machine steps right and writes an alphabet character in every visited state. This means that for computational machines that start with a tape that has a finite input (active area), the output (active area) will be finite. This also means that space complexity can never be larger than time complexity.

- -

A fixed value is one that is provided with a Turing Machine definition, and does not change while the machine runs. Suppose we chose a fixed length Turing Machine tape. The tape would then have a rightmost cell. That cell would have no right neighbor, but would have a left neighbor. We would also add another error, that of right from rightmost. This error would be invoked when the controller attempted to step right from the rightmost cell.

- -

Consider a machine that does not step out of the active area, has constant space complexity, and where this space complexity is less than the fixed length for the finite tape; such a machine would never trip the right from rightmost error, and thus there would be no difference between a finite tape and an infinite one.

- -

Now suppose that we bound the length of the input, and that the maximum space required for such inputs or shorter ones is less than or equal to the length of the tape. Then again, the right from rightmost error would never be taken, and thus the tape would be indistinguishable from an infinite one. (Today we typically pad programs with lots of memory and long address words in hopes this will be the case.) An analogous argument can be made if we bound the number of steps that may be taken.

- -

Now consider the case where we do not fix the length of the input, nor the number of steps allowed, and that space complexity is such that space usage grows with growing input length, at least for very long inputs. For such machines we can always find an input of sufficient length to trip the right from rightmost error.

- -

As another approach to finite computing we can run computations twice. For a given input we first run the Turing Machine variation that does not step out of active area but still has an infinite tape. We watch this machine closely while it is running and find the bound on the active area. Now we can make a second machine that has a fixed length tape at least as long as our active area measurement but is otherwise the same. Now with this second machine we can run the same input and there will be no right of rightmost error, and thus there will be no difference between having the finite tape or an infinite one.

- -

Unlike for the constant space complexity proposal, and the bounded input length proposal, which only work for small subsets of potential inputs, this 'run twice' proposal derives a finite machine that works for any given input which a Turing Machine works for. Though, unfortunately, in all cases the second run will be moot, as we could have simply taken the output from the first run.

- -

In a variation on the run it twice approach, instead of running the first machine, we might instead analyze it and should we be able to surmise a maximum tape length, we could use that.

- -

In yet another approach we can extend the finite tape as needed. We place a control layer over the finite tape. When a step right command from the Turing controller invokes the right from rightmost error, the lower layer allocates memory, lengthens the tape, and then performs the requested step right. As long as this occurs in fixed time, (or of sufficient lesser order time than the dominate order of the time complexity), and as long as there is indeed more memory to allocate - this Turing Machine variation will yield the same order of computational complexity as one with an an infinite tape.

- -

I propose the following Turing Machine variation:

- - - fixed finite alphabet - write before read constraint - variable and extendable finite tape - variable read/write head - variable read value buffer - fixed controlling state machine - fixed left from leftmost error - fixed right from rightmost error - fixed start state - fixed halt state - variable current state - fixed procedure for using these - - -

In our original Turing Machine model, the controlling state machine commands were limited to, do-nothing, step-left, step-right, write, with reading as an implied command. To this list we add append. The append command may only be called when the head is on the rightmost tape cell. This is not limiting because the command may be called from a state that is at the end of an arc triggered by the right from rightmost error. When we have no empty-symbol, append accepts an alphabet symbol and performs a write into the new cell. This is not limiting because if need be, a person can always perform an extraneous write of an alphabet symbol.

- -

With this extendable tape model all Turing Machine components remain finite during computation, though some are arbitrarily large. This variation is more suited for creating a mapping between a Turing Machine and a real program running on a real machine. Specifically, a computation requiring N cells maps exactly to a physical machine possessing at least N cells. The theoretical model and the physical implementation remain perfectly isomorphic provided the physical environment does not exhaust its memory bounds. Because a computational TTCA machine demands strictly finite tape extensions, a physical machine that completes the execution maintains exact structural correspondence. This isomorphism holds continuously as long as memory remains available, even accommodating dynamic hardware expansion such as memory hot-swapping. The theoretical correspondence fails solely upon a hard physical limit being reached during execution.

- -

More about commands

- -

The Turing Machine state controller has a command symbol tied to each state. The Turing Machine procedure then has us take action based on this symbol. This is our current command set:

- - - step-right, causes the head to move to the right neighbor cell. - step-left, causes the head to move to the left neighbor cell. - read, returns the symbol under the head. The returned symbol is then used to chose the transition arc. - write(x), causes the symbol x to be written to the cell that the head is currently on. The symbol x is any symbol from the alphabet. - append(x) may only be called when on the rightmost cell. Extends the tape by one cell, and writes the symbol x into that cell, where x is any symbol from the alphabet. - - -

We are going to relieve the constraint that append can only occur from rightmost. Our new append is functionally identical to adding a cell to the rightmost extremity, and then shifting all the symbols over by one cell starting at the new cell and ending when the new rightmost has been written - and then doing the requested write of x on the right neighbor cell.

- -

We will also include the inverse function for append. delete(append(x)) reads x while deleting the cell that x was in. The current Turing Machine model can emulate this function by shifting all the symbols in cells the right of the head left by one, and then simply not using the rightmost cell.

- -

We are also going to support multiplexed state controllers. Our multiplexed Turing Machine will have multiple heads. One for each separate thread of execution through the state controller. As explained in the following chapters, supporting multiplexing makes our machine more complex, especially in the presence of the delete command. However, we defer that discussion to the relevant chapters.

- -

In cases where successive states are visited in a fixed order it is convenient to combine the commands. We have developed the concept of a command statement to support this:

- - - statement::[direction]command+[modifier][&contract]*[arg]* - direction::- | ε - command::r | w | s | a | d | m | e | ☥ - modifier::◧ ◨ n - command - r read cell under the head - w write cell under the head - s step - a allocate/add/append a new cell - d deallocate/drop/delete cell - m move, no allocation or deallocation of cells, requires fill - e entangled copy - ☥ entangled copy on a new thread - modifier - ◧ operate on leftmost - ◨ operate on rightmost - n repeats n times, n provided through an argument - contracts - h◧ head is at leftmost - h◨ head is at rightmost - examples - -s ; step left - a◧ ; make a new leftmost cell - a◨ ; append to rightmost - sn ; step n times - to derive a longer command, combine them: - as ; append then step - -a-s ; append to the left, step to the left - - -

The left direction is specified with a minus sign, otherwise the direction is taken as right going. So the letter s is the step-right command, and -s is the step-left command. The command s3 steps right three times.

- -

The command a appends and writes a new cell to the right of the head. We use two special characters from the UTF character set to signify the rightmost and leftmost of the tape. This one looks like a little tape with its left cell inked in, ◧, so we use it to stand for leftmost. We use this one, ◨, to mean rightmost. Hence a◨ makes a new rightmost cell, and a◧ makes a new leftmost cell.

- -

In some cases it is possible to implement higher performance implementations for commands when the programmer tells us some additional information. For example a◨&h◨ has identical functionality as a◨, while the programmer also guarantees that we are on the rightmost cell. This saves the function from having to scan to the end of the tape.

- -

We can concatenate the command letters into a string to summarize what would happen sequentially in adjacent state transitions. If these compound commands need arguments, then they are pulled from the argument list in order as they are needed. For example, as means to append, with the parameter for the append taken from the argument list, and then to step.

- -

We support multiplexing with the command e, which is short for entangled. This operator returns what appears to be a second independent machine, but this apparently independent second machine actually shares the same tape with the first machine. It is functionally identical to giving one machine two heads, and thus the ability to have state sets.

- -

The command esr is a compound command referring to sequentially applying three other commands. The e says to make an entangled copy of the head. The s says to step this copy, and the r says to do the read. The analogous esw does a write as the last step. This sort of combination of letters to make more complex commands was inspired by Lisp's car and cdr compositions. Though this is functionally what the command does, its actual implementation might be completely different.

- -

The combination of multiplexing and cell deletion leads to a hazard where one thread can delete a cell the head is on in another thread. We add a collision error continuation to our multiplexed Turing Machine interface because of this situation.

- -

Chapter discussion

- -

The modifications to the Turing Machine leading to our TTCA machine were inconsequential, in that for order of complexity and existence proofs we may swap one machine for the other and the results will be the same.

- -

The original Turing Machine had an infinite tape. In contrast the TTCA machine has a surprising property: for computational problems all of its components remain finite. This follows from the fact that during computation a machine makes a finite number of steps, so the tape can only be expanded to be a finite size.

- - Consequentiality across the design abstraction stack - - -

Choice of realization

- -

- Let us take the example of adding two Arabic representation numbers. Logically this is considered to be a logarithmic time problem. We break the operands into fixed length pieces, and adding them in pairs results in a carry per block. By recursively pairing the blocks and applying the carries, we generate wider carries. Thus we can show that in terms of the logic gates that must be traversed, the sum is a log time operation. -

- -

- Physics comes to a different conclusion. In the worst case, a carry into the least significant bit can affect the sum bit some physical distance away. As the operands get longer, this distance grows in proportion. So given the propagation of information at a fixed speed, the bounding evaluation time against growing operand width is linear time. Even if it is log time in gate count, at some point the interconnect delay will dominate. -

- -

- The logical analysis of the adder given above allowed for unbounded resources, because as the adder operand increases in size, the number of block adders increases without bounds. In any realization there will be a limit on the number of blocks that can be added in parallel. These groups are then processed one by one, and the carry is propagated between them. Consequently, as the operands grow in length without bounds, the adder evaluation time becomes proportional to the number of groups processed. Processing groups in series is a linear time algorithm. -

- -

- It is notable that the time-multiplexed use of computer resources produces the same linear time result as the physics of information propagation analysis for the adder. -

- -

- A Turing Machine program faces a situation analogous to physical constraints. Given the operands are found on the tape, and the carry-in can affect the msb of the sum, the head will have to move ever more cells rightward to convey that lsb information up to the msb. Based solely on the propagation time of that information, addition is found to be a linear time algorithm. This propagation remains computation class limiting even if the Turing Machine is given an unbounded number of independent heads. -

- -

- There appears to be alignment among physical limitations, resource limited computing, and steps spent by Turing Machines while they carry information across a linear tape. This alignment indicates that a reasonable realization will be computation theoretic inconsequential. -

- -

- At this point we have arrived at questions of the physics of computation. The above analysis made use of classical physics. Perhaps realizations based directly on principles from Quantum physics models will be computation theoretic consequential. -

- - -

Choice of implementation

- -

- From Babbage's Analytical Engine of 1842 up to the transition to mechanical relays and vacuum tubes in the 1940s, calculating machines were implemented with gears. The basic principle is apparent to anyone who has seen a mechanical odometer. Consider adding numbers for example: given two odometers, step one back at the same time as stepping a second one forward; when the first one reaches zero, the second will hold the sum. This process can be optimized, but the general idea remains the same. For such machines, a step is a rotation of the main shaft. -

- -

- The Harvard Mark I machine had a main axle speed that maxed out at 3000 RPMs, say 2700 RPMs to keep our math simple. Then this is 2700 steps per minute. The ENIAC was a similar implementation, but one that called out the use of circular shift registers of vacuum tubes instead of mechanical gears. Because there were 10 tubes in a ring register, it took 10 clock ticks to complete one 'rotation'. The clock rate maxed out at 450 kilohertz. That would be one rotation every 1/45,000 of a second, or 2.7 million RPMs, an improvement of three orders of magnitude! -

- -

- Yet, the same program when run on the Mark I took the same number of steps as on the ENIAC. But more importantly, a linear time algorithm on the Mark I was still a linear time algorithm on the ENIAC, etc. Thus, these implementation differences were computation theoretic inconsequential. -

- -

- It feels unsatisfactory to leave out the tremendous difference in clock rates. So let us address this feeling by naming an ENIAC main shaft 'rotation' as a standard 'step'. If we do this, then a Mark I shaft rotation would be 1000 ENIAC steps. Yet, this would merely affect the linear constant in the step count formulas. The same programs can be run, with the same inputs, and asymptotic behavior is the same for both machines, because computation classes do not include the constants on the step count equation. Constant time remains constant; linear, polynomial, and exponential time classes are the same as before. Programs that decide questions would get the same answers when they completed. -

- -

- Because we made an ENIAC shift register turn completion a 'standard step', we have a relative measure, so there is something we can do to create a computation theoretic consequential difference. Suppose we have two ENIAC machines, and we send one speeding away from Earth at an exponentially increasing rate, i.e. increasing red shift, and we observe it from Earth. We will observe that the clock on the traveling ENIAC is growing ever slower, and that a linear time program running on it will be observed to have exponential time behavior. Unfortunately, relativity does not smile upon us, as the people on the spaceship would not see the inverse, a speeding computation on Earth, but rather they would also observe a slowing one. -

- -

- So then, instead we send a spaceship towards Earth, with increasing blue shift, and we would observe that spaceship's ENIAC getting faster and faster. This is still not a computation theoretic speedup, because it is not asymptotic. In finite time, said spaceship would run into Earth, or pass it by and then be red shifting. -

- -

- A designer could purposely slow the clock on a second ENIAC so as to emulate red shift. For this to be more than mere theater there would have to be physical reason to run a slower clock than necessary, for example perhaps for conserving an ever dwindling battery. But slowing computation down, or even stopping it, is typically not useful. However, going the other direction, an ever faster clock does not work, as there is a finite maximum physical clock speed. -

- -

- We get an increasing blue shift situation with Moore's law. If every generation transistors become exponentially smaller, and thus faster, and we consider step times in years, hopping from new realization to new realization, then indeed linear time algorithms on a single realization would be log time algorithms on the generational computer. But chances are this is not an asymptotic, i.e. limit to infinity, phenomenon either. -

- -

Choice of organization

- -

- Superscalar and VLIW computers execute multiple instructions in parallel. Real data dependencies put limitations on how many instructions are available to be executed in parallel, but even discounting this, if a program were executed N instructions at a time, its time to execute would divide by N. This merely affects the linear component of the equation mapping step count to input length, and thus does not change the computation class. Superscalar and VLIW architectures do not affect decisions; indeed they are transparent to programs, so decider problem results cannot change. Hence these techniques are not computation theoretic consequential. -

- -

- In general, by definition, organizations do not change a program's view of the machine, as that is part of the architecture. So organizations will not affect decider results. Also, the memory operations will be the same, as that is viewable state, so space complexity does not change unless time complexity changes. -

- -

- The realization sets fixed resources, so any attempt at parallelization will be bounded, as in the superscalar and VLIW discussion above. Thus at best it can divide the execution time by N. -

- -

- Some organizations can arrange computation in a manner that the base clock can run faster than for other organizations. However, clocks run at a fixed maximum speed. On modern systems they can slow down to reduce heat dissipation or battery consumption, but that does not make programs faster. So if one organization has a faster clock than another, the ratio is merely a linear term contributor. Apart from stopping, there is nothing a clock can do to participate in the decision making of the program. -

- -

- Caching of values sent to the system memory again does not participate in the decision making of a program. We are at best looking at improvements in the linear term. -

- -

- Branch prediction saves the time required to do a full fetch, but fundamentally it does not change the data flow graph of the program. The same decisions are made. -

- -

- Suppose that an organization keeps the operands for a function in a content-addressable memory. When the operands are recognized, it then immediately returns the looked-up value. This approach, called memoization, bypasses the internal looping of the function. Hence, this does participate in the decision making of a program, and could potentially change the computation theoretic complexity of programs with certain properties where the same operands occur in patterns and lead to an expensive computation. Memoization is typically designed into computer languages, rather than being built into the organization of a computer. Chances are, at the computer organization level or lower, it is more efficient to simply execute the presented instructions. -

- -

Choice of architecture

- -

- Common decisions made at the architecture level are those for supporting RISC or CISC, the bit layout and handling of operands, the size of the internal register file, how DMA is to be handled, whether to use memory-mapped I/O or have explicit instructions for it, how interrupts are to be implemented and the number of entries in the interrupt table, what special registers are present and what features are available through them, how virtual memory and its user and process IDs are to be implemented with the possible use of a translation lookaside buffer, what onboard execution units will have direct instructions, the built-in data types, questions of unaligned accesses, bus standards to be supported, if sleep modes are to be present, how the machine will get booted, the security rings that will be supported, details of the hardware virtualization layer, special support for the OS, how the system stack will be handled, potential partitioning of address space, support for large buffers, and memory sharing features: none of these are computation theoretic consequential. -

- -

- As architecture enters the gray area with organization, cache architecture, bus layouts, bus buffers, direct inclusion of write buffers, perhaps a stack cache, prefetch buffers and split-transaction buses: none of these are computation theoretic consequential either. -

- -

- Said features certainly affect performance, but none participate in the decisions the program makes, change the number of execution steps by more than a linear ratio, or alter the memory complexity of the program. -

- - - - -
- - TTCA Turing Machine in Lisp - -

Because our TTCA Turing Machine has finite sized components, we may create a software model for the TTCA Turing Machine without having to make assumptions of the sort that ‘very large approximates the infinite’. Rather we can show a one-to-one mapping of code and data in the software model and the TTCA variation of the Turing Machine. Consequently, the software model and theoretic model are isomorphic.

- -

It follows that we can use our TTCA Turing Machine software to make theoretical statements about computation in the form of programs. By following this path we will learn some interesting things in this chapter about analysis, the meaning of emptiness, data type, the properties of non-destructive vs destructive programming styles, and multi-threaded programming among other things.

- -

The Turing Machine, and our variation of it, may be partitioned into two parts. One part of the part consists of the tape head and the tape. We call this the Tape Transport Unit, as that is the name used for the mechanism that does this work on real tape storage units. The other part of the part is the Controller.

- -

The Tape Transport Unit accepts commands for reading, writing, and moving the head. (In real Tape Transport Units the head is in a fixed position and we move the tape, but the relative affect is the same.) Our modified model adds commands for extending the tape. During normal operation these commands only come from the controller.

- -

We have two types of controllers. One type of controller is a state machine. Its design is an integral part of the Turing Machine. To step the Turing Machine means to step this state machine to its next state. The state machine definition exists before the Turing Machine takes its first step, and its definition remains intact for as long as said Turing Machine exists.

- -

When we speak of a Turing Machine without adding further words to the term as qualifiers, we mean that it uses this type of controller. For clarity we can call this a Directly Controlled Turing Machine.

- -

The second type of controller is the Universal Controller, and a Turing Machine that uses this type of controller is called a Universal Turing Machine. The Universal Controller reads the definition of a state machine controller off of the tape. Hence the Universal Turing Machine may emulate any Directly Controlled Turing Machine. We can also call this an Indirectly Controlled Turing Machine. Here the qualifier ‘Indirectly’ is intended in the sense it is used in assembly languages, meaning the data is not present in the controller, but rather it must be fetched from memory.

- -

With our Tape Machine library, your program is the controller, and the library implements the Tape Transport Unit. (In the future I will rename this library to ‘TTU’ from the current ‘TM’. Also the use of the term ‘function’ will be changed to ‘routine’.)

- -

Your program that uses the TTU library is in a sense direct control, because the program is already defined before the first step of the machine, and with the possible exception of self-modifying code, it does not change until the program exits, and thus the process no longer exists. On the other hand, your program is loaded from memory by the processor, thus demonstrating that the processor is an indirect, i.e. universal, controller. Either interpretation works depending on how broad of a view we want to take.

- -

Installing the library

- -

TM is presented as an iteration library on the de facto package manager for Lisp quicklisp. Alternatively, a person may clone the repository www.github.com/Thomas-Walker-Lynch/tm and then checkout the latest release tag, which as of this writing is v0.7-alpha. After installing the code cd into the tm directory and run your lisp interpreter. Inside your lisp interpreter type the commands (load “load”) and (test-all). test-all should return with a message that all of the tests passed.

- -

It is possible that the threading tests, 'ts1-' might fail if your machine is heavily loaded or very slow, as they have timing built into them, but this is unlikely. Then type either (use-package :tm) or (in-package :tm) depending on what your objectives are.

- -

The examples in this chapter either come from the tm/test directories, or from the tm/docs/examples directory. At the time they were placed in the book, they executed correctly, and I have endeavored to keep the examples up to date.

- -

This is what it looks like when I follow install using the git clone method:

- - - > git clone http://www.github.com/Thomas-Walker-Lynch/tm - Cloning into 'tm'... - remote:Counting objects: 3052, done. - remote:Total 3052(delta 0),reused 0(delta 0),pack-reused 3052 - Receiving objects: 100% (3052/3052),2.41 MiB|1.52 MiB/s,done. - Resolving deltas: 100% (2366/2366),done. - > cd tm - > git tag - v0.1-alpha - v0.7-alpha - > git checkout v0.7-alpha - Note: checking out 'v0.7-alpha'. - You are in 'detached HEAD' state ... - > sbcl - This is SBCL 1.3.14.debian ... - * (load "load") - ; compiling file "/home/tm/package-def/conditions.lisp" - ; compiling (IN-PACKAGE #:TM) ... about 10 pages of these - hooking test: TEST-TS1-5 - T - * (test-all) - + TEST-UNWRAP-0 - ... about a page of these tests - + TEST-TS1-5 - all 78 passed - T - * (use-package :tm) - T - * (≠ 1 0) - T - * - - -

Notice I used git tag to see the releases. At this time, v0.7-alpha is the latest, so I checked that out. If you want the unstable latest code rather than the stable latest release, leave out the git checkout command.

- -

The TM Library makes use of Unicode. There is no getting around it. This is discussed further in the next section. In addition TM defines synonyms for commands such as 'not equal', which is the one command shown at the end of the transcript given above.

- -

Unicode usage

- -

For your convenience there is a file "emacs-keys" in the docs directory of the distribution. It sets the C-x g name SPC command to enter one of the Unicode characters that are used in the library. Here 'name' is a nickname.

- -

So to type the character capital delta after emacs-keys has been loaded, type C-x g D SPC. Actually Δ occurs twice in Unicode, once as capital delta, and once as a symbol for 'increment' in mathematics. We consider the increment version to only be there for typography purposes. We only use capital delta, even when it is for an increment variable.

- -

I've limited the use of Unicode mostly to things that 'probably would have been this way had Unicode been around before'. This includes conventional notation and a couple of symbol extensions that were needed to facilitate the TM access language.

- -

In the file src-0/fundamental.lisp find synonym bindings for the usual operators and common symbols such as ∧, ∨, ≥, ≤, λ, ∅, etc.

- -

Specific to the library we use the character '◧' as shorthand for 'leftmost'. This is because it looks like a little tape with the inked over cell being the leftmost cell. In the same manner the character '◨' is shorthand for rightmost.

- -

We use '➜' in continuation function names, and '⟳' as a loop operator.

- -

The ◧ and ◨ symbols are used in compound command names and for access language statements to indicate operation on rightmost or leftmost rather than the cell the head is on, or, to specify contracts with the programmer of the sort: "this function is only called when the cell is on rightmost."

- -

Since I had symbols for leftmost and rightmost, I started using them generally to mean leftmost or rightmost wherever it was convenient. For example, to shorten up the names of continuations so that parameter lists would fit on a line.

- -

Synonyms

- - - (defmacro defsynonym (old-name new-name) - "Define OLD-NAME to be equivalent to NEW-NAME." - `(defmacro ,new-name (&rest args) `(,',old-name ,@args)) - ) - (defconstant ∅ nil) - (defsynonym /= ≠) - (defsynonym <= ≤) - (defsynonym >= ≥) - (defsynonym not ¬) - (defsynonym and ∧) - (defsynonym or ∨) - (defsynonym string/= string≠) - (defsynonym string<= string≤) - (defsynonym string>= string≥) - (defsynonym lambda λ) - - -

Some reader macros

- -

q – a non literal quote

- -

In Lisp a quoted list is taken as being literal. However the result of modifying a literal is undefined, and often leads to bad results. Hence we provide the macro q which returns a quoted list which is not a literal.

- - - * (q a b c) - (A B C) - - -

{…} - unevaluated list

- -

When a form enclosed in parentheses, ( ... ), is evaluated the head is taken as the name of a function, looked up and called. The list members are also evaluated, and then passed as arguments to said function. If we don't want the head treated specially, but rather want to define a list, we can use a front item of #'list, which is the function to create a list.

- - - * (list 1 2 (+ 1 2)) - (1 2 3) - - -

We have defined a macro called L that like #'list, creates a list, but which also has some extra functionality.

- - - * (L 1 2 (+ 1 2)) - (1 2 3) - - -

We also provide a reader macro for L as braces.

- - - * {1 2 (+ 1 2)} - (1 2 3) - - -

If the apparent function open, #'o, appears inside of a call to L, then the arguments of the #'o function are included directly in the resulting list:

- - - * (defvar a {1 2 3}) - A - * (defvar b {4 5 6}) - B - * {a (o b)} - ((1 2 3) 4 5 6) - - -

Quoted non-literals can also occur within such an L list:

- - - * {a (o b) (q a b)} - ((1 2 3) 4 5 6 (A B)) - * {a (o b) (o (q a b))} - ((1 2 3) 4 5 6 A B) - - -

L acts identically to a quasiquote turned inside out. Whereas the default in quasiquote is to quote items, and a comma operator turns that off, the default in L is to evaluate items, and a q operator turns that off. Quasiquote has an @ marker to open up lists, while L has an o operator to open up lists. Inside of a quasiquote we could get in trouble if the name of a variable starts with an @ character; if such a variable appears after a comma, quasi quote will consider the variable name without the @ sign is to be opened and included. There is no analogous problem with the o operator because it only appears in the function channel. (The problem with quasiquote is that it uses 'in-band signaling' which mixes control with data in one channel.).

- -

[...] - head is variable holding a function name

- -

In Lisp the head of an evaluated list is taken as a function name. Consider this example that curries a two parameter function into a unary function by replacing one parameter with a constant argument of 3:

- - - (defun curry-three (f n) (f n 3)) ; has errors - - -

When we compile this function we get two errors:

- -

The variable F is defined but never used.

- -

and

- -

undefined function: F

- -

The first f is in the parameter list of the function definition, so it is taken as a variable name. In contrast the f in the body is at the head of an evaluated list, so it is taken as a function name. Hence there is a disconnect, and we get error messages describing this disconnect.

- -

The Lisp operator #' indicates that the symbol that follows is a function name to be taken literally, and not a variable name. This gets our function name into the data space for use as an argument. The Lisp function funcall accepts as a first argument the name of a function to be called, while the remaining arguments are passed through to said function as its arguments:

- - - (defun curry-three (f n) (funcall f n 3)) - (defun plus (x y) (+ x y)) - (curry-three #'plus 2) - 5 - - -

In the definition for curry-three we do not get interpreter/compiler errors. This is because f is consistently used as a variable name. funcall will use the value of the variable f as the name of a function to call.

- -

In the second line we define a function to pass into curry-three. I put something simple here for sake of discussion. plus is defined to be a function that takes two arguments and sums them.

- -

In the third line we use the #' operator to tell Lisp that plus is a function name to be used literally as a value. This will be a value passed into curry-three no differently than had we put a number or string instance as an argument. Inside of curry-three the #'plus becomes the value of the variable f. Then the funcall function will use this value as a function name, and then call it.

- -

This is how function pointers are handled in Lisp as it does not have an explicit pointer type.

- -

Actually we didn't need to define the function plus, because '+' is already a function. We don't have reserved operator symbols in Lisp, instead we have loose rules on what can be used for function names.

- - - (curry-three #'+ 2) - 5 - - -

We introduce a shortcut with the TM Library. Normally a list to be evaluated is in parenthesis, and its head is taken literally as a function name. With the TM Library loaded, when a list in square brackets is evaluated, the head is taken as a variable name, and the value of this variables is the function to be loaded. It is a nice coincidence that square brackets mean indirect addressing in many assembly languages.

- -

We implemented this feature with a reader macro which simply turns the square bracket list into a regular list and inserts the funcall as its head. This occurs before the Lisp evaluate phase sees the syntax.

- -

Using the square brackets we may define curry-three as:

- - - * (defun curry-three (f n) [f n 3]) - CURRY-THREE - * (curry-three #'plus 2) - 5 - - -

Here is another example. Suppose that instead of passing #'plus in as an argument, that we first assigned it to a variable and then pass the variable value as an argument:

- - - * (defvar our-fun #'plus) - * [our-fun 4 7] - 11 - * (curry-three our-fun 2) - 5 - - -

Here the value assigned to the variable our-fun is a function name. The variable is then used as any other, and its value is passed in as an argument to curry-three. Note, all arguments are evaluated before the function is called, so variables are replaced with their values. And as we know, inside curry-three, funcall will take the function name value from the corresponding parameter and call it as a function.

- -

Things can become a little confusing when the variable name has the same name as the function.

- - - * (defvar plus #'plus) - * (curry-three plus 2) - 5 - - -

Here #'plus is the function name as data. plus when it appears as the head of an evaluated list is a function name, otherwise it is a variable name. It is little wonder that the Lisp dialect Scheme put function names and variables name in the same space. However by doing so they had to provide some automatic conversions between variable names and function names.

- -

Summary

- -

When evaluated:

- - - - - - Appendix: The Tension Between Formal Methods and Practical Architecture - -

Does computation theory matter to computing?

- -

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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Memory TierReal World LatencyScaled DelayScaled Arrival EraHistorical Context
L1 Cache Hit1 ns3 days-0043-03-18Three days after the assassination.
DRAM (Main memory)100 ns300 days-0042-01-09Nearly a year later, during the Liberators' civil war.
NVMe SSD Page Swap15 µs45,000 days0080123 years later, exactly as the Colosseum is completed in Rome.
SATA SSD Page Swap100 µs300,000 days0778821 years later, during the reign of Charlemagne and the Frankish Empire.
Magnetic HDD Page Swap10 ms30,000,000 days82092Tens of thousands of years in the future, long after current human civilizations are dust.
- -

Do formal methods belong in computer design?

- -

- The latency table above speaks to the physical reality that constrains all programs, entirely independent of their theoretical complexity class. This illustrates why computer architects spend almost their entire effort designing machines that execute as many instructions per cycle as possible, operating within a memory subsystem mathematically optimized to keep data in the lowest latency tiers. As a demonstration of this industry focus, there is not a single chapter dedicated to computation theory in Hennessy and Patterson's definitive textbook on the subject John L. Hennessy and David A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed. (Cambridge: Morgan Kaufmann, 2017).. -

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Chapter 1Fundamentals of Quantitative Design and Analysis
Chapter 2Memory Hierarchy Design
Chapter 3Instruction Level Parallelism and Its Exploitation
Chapter 4Data Level Parallelism in Vector, SIMD, and GPU Architectures
Chapter 5Thread Level Parallelism
Chapter 6Warehouse Scale Computers
Chapter 7Domain Specific Architectures
Chapter 8The Future of Computing
- -

- Professor Gonzalez once observed that the primary purpose of computer architecture is to execute the customer's programs as rapidly as possible. IBM later amended this philosophy to add 'for what they paid for,' famously designing a computer model where performance was artificially restricted unless the customer paid to have a physical hardware jumper removed. Within this prevailing design philosophy, the graceful handling of computational end cases, where most formal theoretical questions arise, is deemed secondary because such cases do not occur frequently in the critical execution path. -

- -

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

- -

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

- -

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

- -

- This continuous tension between pure formal models and practical execution speed remains a defining characteristic of the field, driving the structural logic behind modern mechanisms dealing with instruction pipelines, branch prediction, and memory aliasing. -

- - Appendix: Stirling Numbers - -

- James Stirling introduced these numbers in his 1730 publication, Methodus Differentialis, a text that directly expanded upon the foundational work laid by Newton. -

- -

- The profound utility of Stirling numbers lies in their function as the definitive translation layer between continuous mathematics and discrete mathematics. In the context of the Turing Machine architecture, they are the exact mechanisms that bridge the continuous abstract polynomial with the discrete mechanical steps of the machine. -

- -

- To understand their mechanical role, a person must look at the mathematical basis used in each domain. -

- -

The Continuous vs. Discrete Basis

- -

- In continuous calculus, the natural basis for polynomials is standard exponentiation, t^n. The continuous derivative operator, D, interacts beautifully with this basis, dropping the degree by exactly one: D(t^n) = n t^{n - 1}. -

- -

- However, in the calculus of finite differences, standard exponents are clumsy. Because the Turing Machine evaluates discrete jumps, the natural basis is the falling factorial, denoted as t^{\underline{n}}: -

- -

- t^{\underline{n}} = t(t - 1)(t - 2) \cdots (t - n + 1) -

- -

- When a person applies the discrete forward difference operator, \Delta, to a falling factorial, it behaves identically to the continuous derivative: \Delta(t^{\underline{n}}) = n t^{\underline{n - 1}}. -

- -

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

- -

- The Stirling numbers of the second kind are the coefficients required to project the continuous basis onto the discrete basis. They express standard powers as a sum of falling factorials: -

- -

- t^n = \sum_{k=0}^n S(n,k) t^{\underline{k}} -

- -

- In combinatorics, S(n,k) represents the number of distinct ways to partition a set of n items into k non empty subsets. -

- -

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

- -

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

- -

- The signed Stirling numbers of the first kind perform the exact inverse operation. They reconstruct standard continuous powers from falling factorials: -

- -

- t^{\underline{n}} = \sum_{k=0}^n s(n,k) t^k -

- -

- Combinatorially, the unsigned magnitude of s(n,k) represents the number of ways to arrange n items into k disjoint cycles. The alternating signs account for the algebraic expansion of the falling factorial terms (t - 1)(t - 2), etc. -

- -

- In the context of the quotient machine or the coefficient recovery matrix, taking the inverse of the matrix formed by the second kind inherently generates a matrix composed of the first kind. This provides the direct algorithmic path to extract the continuous polynomial identity from the discrete mechanical state of the tape. -

- -

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

- - - - - - - - - - diff --git a/document/book/Boolos.txt b/document/book/Boolos.txt new file mode 100644 index 0000000..69df079 --- /dev/null +++ b/document/book/Boolos.txt @@ -0,0 +1,31 @@ +The Mechanics of Boolos's Proof +Boolos formalized the Berry Paradox to prove Gödel's Incompleteness without utilizing Cantor's diagonal array or heavy Gödel numbering. Here is the step-by-step logical sequence: + +1. Definability via WFFs +Within any formal mathematical system, we form WFFs using a strict, finite alphabet. A WFF with exactly one free variable, say F(x), "defines" or "names" a specific Natural Number k if the system can definitively prove F(k) is true, and rigorously proves F(y) is false for any y + +=k. + +2. The Physical Limit of Naming +Because the system's alphabet is finite, the total count of valid WFFs containing fewer than N symbols is absolutely finite. Since each WFF can name at most one distinct Natural Number, the total set of numbers definable by fewer than N symbols is also completely finite. + +3. The Inevitable Exception +The set of Natural Numbers is unbounded. Therefore, there absolutely must exist Natural Numbers that require WFFs longer than N symbols to define them. Consequently, by the well-ordering principle of Natural Numbers, there must exist a singular, smallest such number. + +4. The Mechanical Contradiction +Boolos demonstrated that an analyst can form a specific WFF within the formal system, let us call it B(x), which translates logically to the following constraint: + +x is the smallest Natural Number not definable by a formula containing fewer than 10,000 symbols. + +5. The Resolution (Incompleteness) +The formula B(x) itself contains far fewer than 10,000 symbols when written out in the formal alphabet. + +If the axiomatic system is perfectly complete, it must be able to prove B(k) for the actual, correct number k. But doing so results in an immediate paradox. The system would use a short WFF to definitively name a number that the very same WFF asserts cannot be named by a short WFF. + +To remain mathematically consistent, the system simply cannot prove B(k). The exception exists—there genuinely is a smallest unnameable number—but the formal system is too mechanically limited to prove which number it is. + +Integration into the TTCA Book +This proof completely bypasses the unearned assumptions of actual infinity and infinite diagonal sequences. It rests entirely on the finite, physical limitations of alphabets and the finite length of WFFs. + +Since this proof relies so heavily on the mechanical limits of the alphabet, how do you plan to introduce the concept of "definability" to the reader before presenting this paradox in the appendix? + diff --git a/document/book/D_10.png b/document/book/D_10.png new file mode 100644 index 0000000..d7c8887 Binary files /dev/null and b/document/book/D_10.png differ diff --git a/document/book/HU_reverse_machine.png b/document/book/HU_reverse_machine.png new file mode 100644 index 0000000..9771cfb Binary files /dev/null and b/document/book/HU_reverse_machine.png differ diff --git a/document/book/HU_reverse_machine.yaml b/document/book/HU_reverse_machine.yaml new file mode 100644 index 0000000..ae67be8 --- /dev/null +++ b/document/book/HU_reverse_machine.yaml @@ -0,0 +1,43 @@ +# enter this at https://TuringMachine.io/ +# Reverses a binary string +input: '11001' +blank: ' ' +start state: q0 +table: + # scan to the rightmost digit and place the EOM terminator 'E' + q0: + [0, 1]: R + ' ' : {write: 'E', L: q1} + + # process the rightmost unmarked digit, writing the uniform marker '*' + q1: + 0 : {write: '*', R: q2} + 1 : {write: '*', R: q3} + ' ': {R: q6} # all digits processed, begin cleanup + + # carry '0' to the right end + q2: + ['*', 'E', 0, 1]: R + ' ' : {write: 0, L: q4} + + # carry '1' to the right end + q3: + ['*', 'E', 0, 1]: R + ' ' : {write: 1, L: q4} + + # return all the way to the left blank space + q4: + ['*', 'E', 0, 1]: L + ' ' : {R: q5} + + # step right to find the next unmarked digit + q5: + [0, 1] : R + ['*', 'E']: {L: q1} + + # erase the markers and EOM terminator, leaving only the reversed string + q6: + ['*', 'E'] : {write: ' ', R: q6} + [0, 1, ' ']: {L: done} + + done: diff --git a/document/book/RT-Manuscript_locator.js b/document/book/RT-Manuscript_locator.js new file mode 100644 index 0000000..e5ad4f5 --- /dev/null +++ b/document/book/RT-Manuscript_locator.js @@ -0,0 +1,51 @@ +/* + indirect.js + + We have four scenarios + + immediate - used in the RT-Style distribution itself (authored, consumer, staged) + direct - used in the RT-Style project itself, but not in the distribution + indirect - the version all Harmony projects use + URL-only - always pulls style through a URL, a webserver must be present + +*/ + +window.RT = window.RT || {}; + +// --- Configuration --- +// Define the consumer project name to allow dynamic local file:// calculation. +window.RT.project_name = "TM-2026"; + +// Fallback URL when served over a network where the project root is not in the URI. +window.RT.server_url = "http://localhost:8000/shared/linked-project/RT-Style/Manuscript"; + +(function() { + let style_path = window.RT.server_url; + + if (window.RT.project_name) { + const path = window.location.pathname; + const project_root_index = path.indexOf('/' + window.RT.project_name + '/'); + + if (project_root_index !== -1) { + // substring(0, stop) extracts up to the project name, leaving off the trailing slash. + // We append the explicit forward slash before navigating into the shared boundary. + const absolute_project_root = path.substring(0, project_root_index + window.RT.project_name.length + 1); + + // The symlink 'RT-Style' already drops us inside the 'consumer/' directory, + // so we proceed directly to 'Manuscript'. + style_path = absolute_project_root + "/shared/linked-project/RT-Style/Manuscript"; + } else { + console.warn("RT-Style: Cannot locate project root '/" + window.RT.project_name + "/' in URI. Falling back to server_url."); + } + } + + window.RT.dirpr_library = style_path; + + document.write( + ' + + + + + + + + + + + The search that led to the Turing Machine + +

+ In 1893 Gottlob Frege published an axiomatic construction of mathematics from set theory. Frege's grand objective was something he called Logicism, the philosophical thesis that all of mathematics can be derived entirely from pure logic. To bridge set theory and logic, Frege defined sets using a method known as set comprehension. Under this approach, a mathematician states a logical rule or property, and any object satisfying that logical statement automatically becomes a member of the set. Because the membership of a set is determined entirely by logical rules, the resulting sets, and the mathematics built upon them, are derived directly from logic. To implement this, his specific machinery relied upon unrestricted set comprehension, formalized as Basic Law V Gottlob Frege, Grundgesetze der Arithmetik, Vol. 2 (Jena: Hermann Pohle, 1903), Appendix (Nachwort), 253.. +

+ +

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

+ +

+ In 1901 Bertrand Russell found a well formed set formulation using Frege's set theory that did not correspond to a set. As Frege's work was based on this set theory, this called into question his entire work. Russell pointed out that it was possible to define a set of all sets that do not contain themselves. However this was a paradox, because if said set contained itself, it shouldn't, and if it didn't it should. Thus the formulation failed to define a set because the logical condition cannot be satisfied Bertrand Russell, The Principles of Mathematics (Cambridge: Cambridge University Press, 1903), Chapter X, 'The Contradiction'.. Russell communicated this to Frege in a letter dated 1902 06 16, shortly before his second volume was going to print Bertrand Russell to Gottlob Frege, June 16, 1902, reprinted in Jean van Heijenoort, From Frege to Gödel: A Source Book in Mathematical Logic (Cambridge: Harvard University Press, 1967), 124 125. Gottlob Frege, Grundgesetze der Arithmetik, Vol. 2 (Jena: Hermann Pohle, 1903), Appendix (Nachwort), 253. Frege writes: 'Hardly anything more unfortunate can befall a scientific writer than to have one of the foundations of his edifice shaken after the work is finished.'. Frege hurriedly authored an appendix (the Nachwort) admitting his system was compromised Frege was a quiet, rigid man who had spent decades building his logical fortress in almost total academic obscurity. Frege was personally devastated by Russell's letter. Shortly after, he suffered the loss of his wife, fell into severe depression, and his academic output almost entirely ceased. In 1924, a year before his death, he wrote unpublished diaries explicitly surrendering his life's work, declaring that logicism was a mistake and that mathematics must actually be derived from geometry. Note I. Grattan Guinness, The Search for Mathematical Roots, 1870 1940 (Princeton: Princeton University Press, 2000). For an analysis of Frege's intellectual decline, personal tragedies, and his unpublished 1924 1925 diaries where he formally surrenders the logicist program, see Chapter 7.. +

+ +

+ In 1903 Russell proposed a hierarchy of types to repair this foundational vulnerability. At the base were sets of individuals, then sets based on individuals or sets of individuals, etc. This looks a lot like how types work in modern software Bertrand Russell, The Principles of Mathematics (Cambridge: Cambridge University Press, 1903), Appendix B: The Doctrine of Types.. In this manner, it is not possible to write a paradoxical set definition. Russell and Alfred North Whitehead then engineered an entirely new, massive scaffolding utilizing this type system to pursue Frege's original objective of deriving mathematics from logic, publishing their results in three volumes between 1910 and 1913 Alfred North Whitehead and Bertrand Russell, Principia Mathematica (Cambridge: Cambridge University Press, 1910 1913).. Russell's system can be cumbersome due to requiring a large construction to be assembled in place of what otherwise might have been a simple rule. +

+ +

+ In 1908 Ernst Zermelo published an alternative system designed to avoid the known paradoxical statements of the time, even though absolute consistency remained unproven. In Zermelo's set theory, a mathematician first starts with an existing set, and then applies the Axiom of Separation using definite properties to partition out subsets Ernst Zermelo, "Untersuchungen über die Grundlagen der Mengenlehre I," Mathematische Annalen 65 (1908): 261 281.. To see how this works, consider the expression \{x \mid P(x)\}. Under unrestricted comprehension, a logician is permitted to define the predicate P(x) as x \notin x. This produces Russell's Paradox, so the set fails to be defined. In contrast, consider the same predicate, though restricted by Zermelo's Axiom of Separation over a predefined set S, written as \dot{R} = \{x \mid x \in S \wedge x \notin x\}. The only thing a person needs to know about S here is that it has already been successfully defined. So let us ask, is \dot{R} in \dot{R}? If we assume \dot{R} is a member of S, evaluating the second term forces the familiar fatal loop: if \dot{R} is in \dot{R}, it shouldn't be, and if it isn't, it should be. Thus if we assume that \dot{R} is in S, then \dot{R} can not be defined, but by definition, S is defined, and thus its members are defined. As we arrived at a contradiction, the original assumption must be false, i.e. it is wrong to assume that \dot{R} is in S. As \dot{R} is definitively not a member of \dot{R}, the first term of the set comprehension rule, x \in S is false, and the paradox vanishes. +

+ +

+ A person might suggest defining S as the set of all definable mathematical objects, forming a universal set. However, if such a universal set S existed, the Axiom of Separation could be applied using the previous predicate to isolate \dot{R}. Because \dot{R} is a valid, definable set, it must reside within S by the very definition of a universal set. But notice that the logic evaluated earlier proved definitively that \dot{R} cannot be a member of S. Yet the existence of a definable set \dot{R} that sits strictly outside of S contradicts the premise that S contains everything. Therefore, within any system governed by the Axiom of Separation, a universal set cannot exist. +

+ +

+ The authority to remove the Russell's Paradox set formulation comes from the set S. If we know its definition, then the authority comes through that definition. However, if we merely stipulate that S must be defined, then we are expressing our authority through S by declaring, "Undefined sets are not allowed." In the explanation above, it is only after discovering a set is undefined that we conclude it is not a member of S. I sometimes wonder how mathematics might have evolved had Frege simply taken that approach. We take this question up again in the chapter Computational Naturalism, and discover there is a deeper issue. +

+ +

+ Stepping back from the mechanics of set definition, a person can observe two competing approaches to establishing mathematical foundations. The first approach is constructive, building complex systems by assembling them upward from fundamental primitives. The second approach relies on islands of meaning, carving out valid spaces from the abstract void using precise rules and axioms, exactly as Zermelo did. Because both methodologies rely entirely upon a rigorous framework of deduction to function, logic itself serves as the essential substrate. Consequently, a complete foundational study requires the examination of three distinct subjects: the primitives used for construction, the rules that bound the theoretical islands, and the underlying logic that evaluates them both. +

+ +

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

+ +

+ In 1931 Kurt Gödel published his incompleteness theorems Kurt Gödel, "Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I," Monatshefte für Mathematik und Physik 38 (1931): 173 198.. By mapping formal logic into arithmetic, he demonstrated that any consistent formal system sufficiently powerful to perform basic arithmetic, let us call it system S, will inevitably contain well formed formulas that are mathematically true yet cannot be proven within the system itself For the definitive English translation, see Jean van Heijenoort, From Frege to Gödel: A Source Book in Mathematical Logic, 1879 1931 (Cambridge: Harvard University Press, 1967), 596 616.. Gödel achieved this by engineering a specific formula that evaluates to the claim: "G: There exists no sequence of valid logical steps within system S that proves G." If system S is consistent, it cannot output a proof for G; thus, the claim G makes is factually accurate, rendering it true but mechanically unprovable. Furthermore, Gödel demonstrated that system S cannot output a proof of its own consistency. This result fractured David Hilbert's 1900 vision of utilizing a weaker, strictly "finitistic" logical subsystem to definitively prove that the axioms of arithmetic are entirely free of contradictions David Hilbert, "Mathematical Problems," Bulletin of the American Mathematical Society 8 (1902): 437 479.. If the full, powerful system S physically lacks the mechanical capacity to verify its own consistency, Hilbert's weaker finitistic subsystem is definitively incapable of accomplishing the task. Gödel's work established a hard mechanical boundary, asserting that truth and provability are distinct concepts in classical mathematics. +

+ +

+ In April 1936, Alonzo Church leveraged Gödel's foundational papers to directly answer the Entscheidungsproblem Alonzo Church, "An Unsolvable Problem of Elementary Number Theory," American Journal of Mathematics 58, no. 2 (April 1936): 345 363.. Working independently, Alan Turing had arrived at his own mechanical solution, and upon seeing Church's April publication, Turing rushed to submit his manuscript on 28 May 1936, appending a proof that his mechanical architecture was mathematically equivalent to Church's lambda calculus Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265. Received May 28, 1936, published November 30, 1936.. As Hilbert and Ackermann concede in the 1938 second edition of their textbook, Church's results demonstrated that "the quest for a general solution of the decision problem must be regarded as hopeless" David Hilbert and Wilhelm Ackermann, Principles of Mathematical Logic, 2nd ed. (New York: Chelsea Publishing Company, 1950), 124.. By giving the "somewhat vague intuitive concept of recursion a certain precise formalization," Church proved the "non existence of such a recursive procedure" that could mechanically yield a value of truth or falsehood for every individual formula Ibid., 124.. +

+ + +

+ 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 'studied' program will halt when it is run Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265.. An answer to this halting problem (specifically asserting "The studied machine halts" or "The studied 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. +

+ + +

+ Turing employed an enumerative diagonal argument to establish this result. A simpler proof by contradiction that is commonly used today was first published by Christopher Strachey in 1965 Christopher Strachey, "An Impossible Program," The Computer Journal 7, no. 4 (January 1965): 313. In his letter, Strachey explicitly attributed the distilled logic to an existing "well known piece of folklore among programmers.". To begin the proof, assume a person builds a perfect decider program, H(p, i), that evaluates any given program p executing with input i, then outputs 'Y' if p(i) halts, and 'N' if it does not halt. Next, a person writes a malicious program, M(x), that incorporates H as a subroutine. When M receives an input program x, it evaluates H(x, x) to determine how program x behaves when given itself as input. If H(x, x) outputs 'Y', M enters an infinite loop; if H(x, x) outputs 'N', M immediately halts. +

+ + + M(x){ + if(H(x ,x) == 'Y') while(true); + else if(H(x ,x) == 'N') return; + } + + +

+ The evil part occurs when we give program M(x) itself as input, M(M). Program M calls its subroutine and asks H(M, M) what M will do. If H outputs 'Y', it is wrong, because M loops infinitely. If H outputs 'N', then it is wrong, because M halts. The decider H is forced into an inescapable failure, proving that no universal decider can exist. +

+ +

+ While Gödel, Church, and Turing established the primary boundaries of computation, they did not work in a vacuum. During this period, the broader academic community worked to synthesize the definitive mechanics of effective calculability. Jacques Herbrand and Gödel formalized general recursive functions between 1931 and 1934 Kurt Gödel, "On Undecidable Propositions of Formal Mathematical Systems," mimeographed lecture notes, Institute for Advanced Study, Princeton, 1934.. Emil Post independently defined "Finite Combinatory Processes" in 1936, outlining a theoretical architecture functionally identical to Turing's model Emil L. Post, "Finite Combinatory Processes Formulation 1," The Journal of Symbolic Logic 1, no. 3 (September 1936): 103 105.. Stephen Kleene subsequently unified these disparate threads, proving the strict mathematical equivalence of Church's lambda calculus, Herbrand Gödel recursive functions, and Turing's mechanical architectures Stephen C. Kleene, "General Recursive Functions of Natural Numbers," Mathematische Annalen 112 (1936): 727 742.. +

+ +

+ The academic community was thus equipped with three mathematically equivalent foundations for computation theory: recursive functions, the lambda calculus, and the Turing Machine. While all three frameworks remain active subjects of study, Turing's model is unique in providing practical intuition through the abstraction of physical machines and programs. This made it the foundation of choice for computation theory textbooks by Stephen Kleene Stephen C. Kleene, Introduction to Metamathematics (Amsterdam: North Holland, 1952)., Martin Davis Martin Davis, Computability and Unsolvability (New York: McGraw Hill, 1958)., and Marvin Minsky Marvin L. Minsky, Computation: Finite and Infinite Machines (Englewood Cliffs: Prentice Hall, 1967)., leading to the modern standard presentations by authors such as John Hopcroft and Jeffrey Ullman John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison Wesley, 1979)., as well as Harry Lewis and Christos Papadimitriou Harry R. Lewis and Christos H. Papadimitriou, Elements of the Theory of Computation (Englewood Cliffs: Prentice Hall, 1981).. +

+ + The Turing Machine transforms mathematics into computing + +

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

+ +

+ For Turing's purposes working on the Entscheidungsproblem, establishing functional equivalence between algorithms and Turing Machine programs was sufficient. However, when the Turing Machine serves as a foundational model for computation theory, we are led to ask another question: whether the Turing Machine is representative of modern architectures, and to the extent it differs, how this would affect the applicability of computation theoretic results. +

+ +

+ In reading Alan Turing's 1936 paper, it is striking how modern the text feels, specifically because he discusses algorithms, stored programs, and the mechanical limits of computation. + While his contemporaries largely built purely mathematical and logical frameworks, Turing uniquely tied computation theory directly to the abstraction of machines executing stored programs. Because physical hardware capable of executing stored memory programs had not yet been invented, this explicit architectural grounding makes Turing's work remarkably prescient. Still, Turing could not formally connect the Turing Machine to modern architectures, simply because those architectures did not yet exist. Here, by modern, I refer to architectures utilizing random access system memory, dedicated instruction fetch streams with dynamic branching, and discrete processing units. Though Charles Babbage's 1842 Analytical Engine touched on these concepts, they would wait until the 1940s to reemerge. The practical engineering context of 1936 was limited to calculating machines programmed via patch panels. Hence, for example, there is no explanation in his paper as to why a von Neumann architecture machine (1945) running a program would exhibit the computation theoretic results derived from a computation theory based on the Turing Machine (1936). +

+ +

+ Furthermore Turing's a machine from his 1936 paper utilizes binary. George Boole's work (1847, 1854) was well established by then, so from a theoretical standpoint, it was a sensible simplification. However, utilizing binary within the context of a machine description effectively bridged the gap to the more practically minded engineers of the time. Alan Turing's paper arrived at the same time that switched telephone networks had reached a scale that made them difficult to maintain without systematic approaches. These networks were built upon electromechanical relays, which were decisively binary devices. At least seven men in addition to Alan Turing appear to have independently contemplated the intersection of Boolean algebra, logic, and physical computing: Victor Shestakov (1935, proposed mapping Boolean algebra to electromechanical relay circuits), Konrad Zuse (1936, adopted base 2 architecture to bypass the physical complexity of decimal mechanical gears), Akira Nakashima (1936, published the mathematical equivalence of Boolean algebra and two terminal switching networks), Louis Couffignal (1936, proved calculating machines must shift to binary linkages to reduce physical friction), Claude Shannon (1937, published the definitive mathematical proof mapping Boolean algebra to electrical relays), George Stibitz (1937, constructed the first electromechanical binary adder), and John Vincent Atanasoff (1937, adopted binary to keep the vacuum tube count of electronic circuits physically viable). +

+ + +

+ To complete the Turing Machine story then, we will transform the Turing Machine into a modern architecture in a stepwise fashion, while ensuring that at each step the modifications are inconsequential to computation theoretic existence proofs and complexity class results. We do run into some problems, so the architecture we derive will be a little different from those we currently build. Though the point here is, we could build it. +

+ +

+ The infinite tape is not as large of a hurdle as it might seem at first. For computational problems, the Turing Machine halts in a finite number of steps. Because the Turing Machine is limited to stepping the read/write head over one cell per machine execution step, in a finite number of steps, only a finite amount of tape is ever used. But for a given computation, how much tape is that? Resolving this by assuming more tape is simply attached when needed is analogous to cheating in a 'guess the bigger number' game by declaring, "My number is always one bigger than the given number, so I will tell you my guess after you state your number." Some mathematicians suggest that what is meant by infinity is precisely a rule of this sort. For engineers building physical hardware, however, to state that a resource starts finite and expands incrementally over time is a very different proposition than being asked to install infinite memory on a machine in the first place. +

+ +

+ In 1967, Marvin Minsky addressed this very topic in saying: "We need not think of the machine's tape as infinite. We imagine instead that the machine begins with a finite tape, but that, whenever an end is encountered, another unit of tape is attached." Marvin L. Minsky, Computation: Finite and Infinite Machines (Englewood Cliffs: Prentice Hall, 1967), 167. In 1967, this was a perfectly natural thing to suggest, as computers utilized magnetic tape memory on manually mounted reels, and it was entirely possible for a computation to stop and request a new reel of tape to be mounted. Contemporary computer architectures do, in fact, achieve a similar effect through virtual memory. When physical RAM is depleted, the operating system pauses the active process and autonomously provisions apparent capacity by swapping memory pages out to auxiliary storage. However, this illusion of infinite tape remains bound by the physical limits of the secondary storage and the boundaries of the processor's address space. Once the available swap space is exhausted or the address space is saturated, the operating system abruptly terminates the process. +

+ +

+ Like a Turing Machine, a computer architecture is an abstraction. The box sitting on a person's desk is a realization of some computer architecture. To say a Turing Machine does something is to say that the Turing Machine was analyzed and the result of the analysis is that 'something'. A computer architecture can also be analyzed. A computer architecture is said to be Turing Complete when through analysis it is determined that it can do anything that a Turing Machine can do. The practical implications for a realization of a computer architecture are that running a program will only throw an error because a) the program logic told it to, b) the program has a flaw, or c) there is a mathematical fact standing in the way of execution. It is tolerable to call a computer architecture Turing Complete if it has the built in ability to pause a program until a 'more memory' request is fulfilled. If there can be any other errors from a realization running a program, such as running out of address space or integer overflow, then the architecture is not Turing Complete. +

+ + + The computer design abstraction stack + +

The six levels

+ +

+ There are a number of discernible levels to the computer design abstraction stack: +

+ +
    +
  1. mathematical logic
    2. +
  2. computation theory
    3. +
  3. architecture
    4. +
  4. organization
    5. +
  5. implementation
    6. +
  6. realization
    7. +
+ +

+ Mathematical logic underpins the computation theory layer. Computation theory speaks of the time and space complexity of algorithms and the existence of solutions to decider problems, which in turn guides the goals of the architecture and organization layers. +

+ +

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

+ +

+ It is not a requirement of a computer organization, nor an architecture, that it be capable of physical realization. The abstract Turing Machine organization developed in a later section serves as an example. Instead, an abstract organization can serve other purposes, in this case as a stepping stone to another organization that can be realized. +

+ +

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

+ +

+ If a computer manufacturer keeps the architecture as a constant, all other levels can change, and a customer will be able to run the same software. The same organization can be used with different implementations. Minor changes in manufacturing process can sometimes be used with an older implementation, for example a simple transistor shrink. +

+ +

The levels are not independent

+ +

+ The layers are merely idealizations. In both practice and theory it is not possible to completely disentangle them. On a new machine of the same architecture, it is common that some software will require updates to run, and almost certainly specific operating system support will be required. +

+ +

+ An architect almost always has a reference organization in mind, and design architects work with design engineers to know what is practical, and design engineers work with manufacturing engineers to know what can be built. +

+ +

+ The common understanding of the word 'architecture' is what Hamacher and Zaky call an organization. For example, even the most experienced of architects will say things like a microprocessor has a "superscalar architecture", though whether a processor is a scalar, superscalar, or VLIW machine is clearly a question of computer organization. +

+ +

+ In fact, architecture instructs organization. When an architect designs an instruction set that has load instructions, it implies that there will be an instruction fetch, and thus an instruction bus. Furthermore the load data has to come from somewhere, so there will be data fetch and a data bus. Could both be the same bus? If not, then we have a "Harvard Architecture". The fact is, almost no one involved in computer design completely divorces architecture from organization. +

+ +

+ This cascades down the stack, as organization instructs implementation, etc. For example, if the architecture has an instruction that names one of N registers as an operand, then the organization has a register file that data flows to and from, and busses to carry that data, the design will specify a register file and layout the busses, and the manufacturing people will build them. +

+ +

Where the Turing Machine fits in

+ +

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

+ + Computation theoretic consequentiality + +

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

+ +

+ When a transform applied to machine m_i produces machine m_{i.1}, and this latter machine gets the same results for the same computational inputs, and furthermore, if any computation theory analysis applied to m_{i.1} yields the same 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

+ +

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

+ + + m_i(x_{i,j}) = r_{i,j} + + +

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

+ + + \begin{aligned} + m_8(x_{8,0}) &= r_{8,0} \\ + m_8(x_{8,1}) &= r_{8,1} \\ + m_8(x_{8,2}) &= r_{8,2} + \end{aligned} + + +

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

+ +

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

+ + + m_i \xrightarrow{T} m_{i.1} + + +

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

+ + + \forall j \colon r_{i,j} = r_{i.1,j} + + +

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

+ +

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

+ + + \forall i, \forall j \colon r_{i,j} = r_{i.1,j} + + +

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

+ +

Definition of the computation theoretic consequential/inconsequential transform property

+ +

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

+ +

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

+ + + a_{i,k} = q_{i,k}(m_i, \{x_{i,j}\}) + + +

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

+ +

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

+ + + m_i \xrightarrow{T} m_{i.1} + + +

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

+ + + \forall k \colon a_{i,k} = a_{i.1,k} + + +

+ then T is computation theoretic inconsequential for m_i. +

+ +

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

+ + + \forall i, \forall k \colon a_{i,k} = a_{i.1,k} + + +

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

+ + +The computation theory Turing Machine + +

The Hopcroft and Ullman Turing Machine

+ +

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

+ + + M = (Q, \Sigma, \Gamma, \delta, q_0, □, F) + + +

Where the components have the following meanings:

+ + + +

I have introduced the qualifier programmed in front of the finite state machine controller because each Turing Machine that accomplishes a different task has a different finite state machine controller. The rest of the Turing Machine remains fixed. Hence, when the mathematician defines a custom task controller, he is essentially programming the machine.

+ +

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. In the architecture description given below, those symbols exclusive to the larger set are called control symbols. Hopcroft and Ullman have included the empty symbol as a control symbol. However, they have simultaneously listed it as a separate component.

+ +

State transitions are gated by the read value from the tape. Each state transition function includes actions to be taken, hence their programmable controller is a Mealy style state machine. The step action is mandatory, though it can be in either direction. The write action must be specified, but the write could be the same symbol that is read, hence it is actually an optional action.

+ +

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 \delta(q, X_i) = (p, Y, L); i.e., the next move is leftward. Then, +

+ + + X_1 X_2 \cdots X_{i-1} q X_i X_{i+1} \cdots X_n \underset{M}{\vdash} X_1 X_2 \cdots X_{i-2} p X_{i-1} Y X_{i+1} \cdots X_n + + +

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

+ +

Here is the programmed controller for a Turing Machine that reverses a binary string.

+ + HU reverse machine + +

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

+ + ```yaml + # Reverses a binary string using a single marker and an EOM terminator. + input: '11001' + blank: ' ' + start state: q0 + table: + # scan to the rightmost digit and place the EOM terminator 'E' + q0: + [0, 1]: R + ' ' : {write: 'E', L: q1} + + # process the rightmost unmarked digit, writing the uniform marker '*' + q1: + 0 : {write: '*', R: q2} + 1 : {write: '*', R: q3} + ' ': {R: q6} # all digits processed, begin cleanup + + # carry '0' to the right end + q2: + ['*', 'E', 0, 1]: R + ' ' : {write: 0, L: q4} + + # carry '1' to the right end + q3: + ['*', 'E', 0, 1]: R + ' ' : {write: 1, L: q4} + + # return all the way to the left blank space + q4: + ['*', 'E', 0, 1]: L + ' ' : {R: q5} + + # step right to find the next unmarked digit + q5: + [0, 1] : R + ['*', 'E']: {L: q1} + + # erase the markers and EOM terminator, leaving only the reversed string + q6: + ['*', 'E'] : {write: ' ', R: q6} + [0, 1, ' ']: {L: done} + + done: + ``` + +

This machine starts with the head on the leftmost symbol of the input string, requiring an empty symbol on both sides to operate. The machine begins by sweeping right to place an end of message marker, E, immediately after the string. It then enters a repetitive process: it walks left to locate the next unprocessed input symbol, overwrites it with an asterisk to mark it as read, and then carries that remembered value rightward to deposit it at the new end of the sequence. By executing this back-and-forth shuttle, the machine systematically builds the reversed string to the right of the E, finishing by sweeping through to erase its temporary markers.

+ +

Reversing a string does not in general require knowing the constituent symbols; however, a Turing Machine is incapable of ignoring their actual values. The 1 and 0 here are explicitly stated in the state transitions, and specific states are reserved to keep track of which symbol is being transferred. Had the input alphabet been large, this controller would have required proportionally more states.

+ +

Although by definition each state transition matches one value under the head, as a practical matter, disjunctive selection is allowed via a comma list. A conjunctive phrasing for the state transition proposition would require stringing intermediate states in series.

+ +

The empty symbol

+ +

An initial tape is often said to be empty when every square holds an empty symbol.

+ +

In some proofs, an empty symbol is written over a data symbol on the tape to erase it. Thus, a machine allows the replacement symbol specified in a state transition to be the empty symbol.

+ +

Computational theorists often describe a two-step process. First, a Turing Machine writes an input string onto a tape that was initially filled with all empty symbols, and second, another Turing Machine recognizes if said input string fits a particular pattern. In this manner, a tape is used as a communication medium, and it follows that communication theory can be applied to this messaging scenario. Messages sent on a channel must be formatted so they can be placed on the channel and later recovered. Such an organization is called a communication protocol. The protocol implies a higher authority, as both the sender and the receiver must have knowledge of the same designed-in protocol. In a sense, a protocol is the meta-message sent before the message itself.

+ +

The intention of placing the empty symbol in \Gamma but not in \Sigma appears to be that of reserving the empty symbol as a control component in a communications protocol. This protocol was designed by mathematicians with the intention of making it impossible for programmers to define input tape messages that cannot be recovered by a receiving recognizer Turing Machine. In short, the empty symbol is used as an in-band EOT (end of transmission) symbol.

+ +

If so, this protocol fails to prevent programmers from defining Turing Machines that output messages that cannot be recovered by a receiving Turing Machine, because the Turing Machines were bestowed with the ability to erase characters. An input machine could, for example, happily output an array of strings while using the empty symbol to separate the elements of the array. Nothing in the Turing Machine definition prevents this.

+ +

Furthermore, the Universal Turing Machine can act as the aforementioned higher authority. In this case, Turing Machines, and sometimes their tapes, are written to a Universal Turing Machine's tape. Hence, it is not only possible to want to terminate strings, as mentioned in the prior paragraph; the termination issue itself is embedded in proofs such as the Halting Problem.

+ +

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

+ +

If we are to design communication protocols, there are better ways to do it. Out-of-band control, such as packet communication or run-length encoding, has superior characteristics.

+ +

But if the empty symbol is merely an EOT encoding, then why call it empty?

+ +

A bookshelf is said to be empty when there is no obstacle to enshelving a book or other object on it. This is not to say there is nothing there in the first place. Air gets displaced; if the bookshelf is underwater, it can still be empty because a book can be placed on it. The air, or the water, does not present an obstacle. If the bookshelf is limited to only hold books, then a shelf is empty when no book is available, and not empty otherwise. Attempting to pull a book from an empty shelf simply fails, rather than yielding a volume titled Meditations upon Emptiness.

+ +

In this sense then, a Turing Machine is always empty, as no symbol on the tape presents an obstacle to writing a new symbol.

+ +

There are some concepts that cannot be represented as a symbol. For example, the concept of a symbol that remains on the tape as an obstacle to further writes to the same tape cell is not representable with the current Turing Machine design. It is not beyond our imagination to modify the Turing Machine to facilitate such a feature; a person could set aside a control symbol that, once written, the machine would refuse to overwrite. However, the Turing Machine as defined does not support such a symbol.

+ +

Another concept that cannot be represented with a symbol on a Turing Machine is that of the unknown. The very workings of the Turing Machine depend upon state transitions based on matching a symbol. A person could modify a Turing Machine to non-deterministically explore all possible branches upon seeing such a symbol, but that is mathematically flawed; a cell with an unknown value actually holds only one specific value, the problem being that the value remains unrevealed. There is no general concept built into the Turing Machine of taking multiple branches and then, through some means, testing to see which was the correct branch. Any attempt to do this will have to incorporate a testing concept. The unknown is not merely a theoretical curiosity, because this is how real computer memories are initialized.

+ +

Emptiness is another concept which a Turing Machine symbol cannot represent. As mentioned above, all symbols can be written with equal ease to the tape. A state machine could have an arc where, upon reading an empty symbol, the machine goes to the error state, indicating that the read failed, but this is not the definition given for the computational Turing Machine.

+ +

For reasons of supporting recursion, the computation theoretic Turing Machine given in the next section will have a set of predefined symbols that are included with the alphabet of symbols, rather than being excluded. Where a communication protocol is required, the Turing Machine programmer must define it. It might be that surrounding an input string with empty symbols is a well-suited protocol; however, while the formal definition initializes the tape this way, treating those symbols as a structural boundary is a programmed behavior, not something built into the machine's definition.

+ +

For reasons of supporting recursion, the computation theoretic Turing Machine given in the next section will have a set of predefined symbols that are included with the alphabet of symbols. Where a communication protocol is required, the Turing Machine programmer must define it. It might be that surrounding an input string with empty symbols, is a well suited protocol, but this is not built into the machine definition.

+ +

The singular-unknown

+ +

In the first edition of this book, I introduced a "no read until after write" rule so as to side step the empty symbol issue. This did not displace the need for a communication protocol when tapes were sent as messages, but it did make it possible to remove the empty symbol from programmed controller definitions.

+ +

The standard 9 track tape introduced by IBM in 1964 came from the factory unformatted, the format operation would then write a header and an EOF marker, to mark the end of the device file. Then when an standard library call, such as open(), followed by write(), would writer over the EOF marker, and continue to write the data, then would write a new EOF marker, essentially pushing back the EOF marker. EOF could be pushed back until the physical EOT marker was struck. This is similar in some ways to the how the empty symbol is being used on the computation theoretic Turing Machine as we see in the Hopcroft and Ullman book if we consider the blank to be an EOF marker. However, there is a difference in that the real machine would never use an EOF to erase data characters. Note then while using the standard library, the blank part of the tape could not be read until after it was written, so early tapes indeed enforced the "no read until after a write" rule.

+ +

Note, however, if the programmer seeked the head back into the device file to do write the device EOF would be nowhere in site. The burden of the "no read until after a write" rule would then fall on the shoulders of the programmer, as would the structuring of the data.

+ +

Core memory, and then 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. That approach; however, 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 is created in memory then scrubbed with zeros. If the computational Turing Machine's blank symbol maps to a word of zeros, then the blank symbol would still not be a good model, because generally the data message, say sent between the input writer, and the recognizer receiver, will also contain many zeros. The nice part is if a programmer attempts to dereference a zero pointer, there will be a segment fault. So in this system the program is again burdened with maintaining the "no read until after a write" rule.

+ +

The computation theoretic Turing Machine can instruct computer architecture through a detection of failure of "read after write" if instead of an empty symbol, the machine is modified to support the singular-unknown symbol.

+ +

A singular unknown is a valid single value read from the tape, but despite being able to discern it as a symbol, no decision can be based on its value. However, it is a valid operation to copy it to another cell on the tape. The current computer theoretic Turing Machine definition has no ability to effect his specification. By the current definition, every state transition reads the value under the head, and then gates to the next state based on that value. Hence, there is no escape from making a decision based on the value under the head, and as each state transition comes with a mandatory step, there will be a different value under the head in the next state.

+ +

The TTCA computation theoretic Turing Machhine

+ +

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

+ + + M = (Q, \Sigma, κ, A, \lambda, \delta, q_0, q_h, q_e) + + +

Where the components are redefined to strictly model a Moore machine organization:

+ + + +

+ By separating the operational action \lambda from the transition evaluation \delta, the tuple accurately reflects a Moore machine organization. The action is securely bound to the state itself, exactly matching an architecture where each entry in the state dictionary executes one machine action before resolving the next state list. +

+ + + The Turing Machine architecture/organization + + + + +If a computation requires a two way infinite tape, the single ended tape machine can emulate it 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. When analyzing the time complexity of an algorithm, this overhead merely doubles the constant on the linear term, leaving the asymptotic order of complexity entirely unchanged. The outcomes of decider programs are unaffected. Therefore, utilizing a single ended tape is an inconsequential variation of the two way tape machine. +

+ +
+ Figure 1: A Turing Machine +
Figure 1 A Turing Machine
+
+ + +

Symbol in mathematics

+ +

+ A symbol is a distinct mathematical object capable of being instantiated. Within a given context, any instance of a specific symbol evaluates as equal to any other instance of that identical symbol, and evaluates as not equal to any instance of a different symbol. +

+ +

+ Put more formally, given a set of instantiable objects and a collection of instances made from them, for these objects to be symbols, two conditions must be met. First, it must be possible to define an instance comparison operation, denoted =, that acts as an equivalence relation to partition the collection into discrete equivalence classes. There must be a one to one correspondence between the resulting equivalence classes and the original instantiable objects from which the member instances were derived. +

+ +

+ It follows from this definition that the distinct equivalence classes can be used as a proxy for the instantiable objects themselves. That is, a person can name either the instantiable object or the equivalence class, and then through this correspondence, find the other. +

+ +

Symbol in computing

+ +

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

+ +

+ A symbol instance newly minted by the factory is said to come direct from the factory. A symbol instance direct from the factory is also called an original. +

+ +

Required properties of symbol factories

+ +

+ Any two symbol instances returned directly from two distinct factories will always evaluate to False during an equality comparison. In other words, two distinct originals will always be not equal. +

+ +

+ 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 any two originals, say A and B, it is established that A is not equal to B, as discussed above. Note also that A is not equal to any copy stemming from B, and B is not equal to any copy stemming from A. +

+ +

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

+ +

Instance implementation

+ +

+ Within a process, a reference to the factory can be used as a symbol instance, which will cause the factory to become trivial. Making a new instance will merely require copying the factory reference, and there will be nothing in memory that the base factory reference is pointing to. +

+ +

+ In general, memory addresses are built in symbol instances, hence within the context of a single process run, a program can make use of these symbols. However, this diminishes the size of the address space and leaves the memory at those addresses unused. A common hedge is then to use references into a dictionary, where the data looked up in the dictionary is the name of the symbol. +

+ +

+ Such symbol names are non structural strings, so they do not need to follow the rules of symbols. For example, a program written where references to strings were used as symbol instances, could give multiple, or all, strings the same name, and the program would function. Conventionally, the names are made to be distinct so as to avoid confusion. The hazard here is that a programmer will then conflate the string name with the symbol instance, and perform symbol operations with it. +

+ +

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

+ +

+ As another alternative, each factory can be given a base string, and then make returns a copy of the base string. Here we refer literally to the string as the symbol instance. There is no separate name, and the string data, not the reference to the string, becomes the symbol instance. This is however merely an architectural constraint, under the hood an implementation could use string references as long as it always appears to the programmer that the string value is being used. +

+ +

+ At the time of this writing many machines use 64 bit words. This is equivalent to 8 ASCII characters, while the average size of an identifier is about 5 characters. Hence the approach of using a string as a symbol might not be as inefficient as it seems to be at first. Using strings has advantages. Symbol instances can carry semantic clues for the programmer. There is no hazard of conflating the string instance with the name, as they are the same. Also, a string instance will have integrity across contexts, such as between invocations or when passed between processes (note the section below on crossing context boundaries). A drawback is in cases there is no language support, the strings are typically ad hoc so the guarantee of distinctness becomes merely a contract with the programmer. +

+ +

Distinctness across contexts

+ +

+ If a symbol persists across contexts (such as across scopes or processes), it must remain distinct from all other symbols in its new context. +

+ +

+ One way to meet this requirement is to find a scope encompassing both contexts and to place the symbol factory there. Another solution is to give each context a distinct root symbol and to use an array of symbols in place of the imported symbol. Yet another approach is to associate an imported symbol with a new symbol in the given new context using a correspondence map. +

+ +

+ When utilizing memory addresses as symbols in a virtual memory environment, the convention is to disallow addresses in one process from being used in another. If that isolation is insufficient, it is often adequate to use indexes instead of addresses, taking the address to the base of the data structure. Though the absolute address of the data structure might differ across contexts, the relative offset remains constant. Another approach is to reserve memory address blocks and to guarantee imported pages have the exact same addresses as before, though they might be imported sequentially to reuse the memory block. In architecture, this is generally known as the pointer swizzling problem. +

+ +

Symbol copy consequentiality

+ +

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

+ +

+ Fortunately, the Turing Machine is defined with a finite alphabet and a couple of additional symbols. As these are part of the machine definition, and thus do not change at run time, there is no growth in size, and the time to copy them is inconsequential. +

+ +

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

+ +

Alphabet

+ +

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

+ +

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

+ +

Symbol implementation examples

+ +

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

+ + + /* The enum definition acts as the factory. */ + typedef enum { + SYMBOL_EMPTY = 0, + SYMBOL_ZERO = 1, + SYMBOL_ONE = 2, + SYMBOL_A = 3, + SYMBOL_B = 4 + } TapeAlphabet; + + /* Instantiating copies of the symbols: */ + TapeAlphabet cell_1 = SYMBOL_A; + TapeAlphabet cell_2 = SYMBOL_A; + + /* Equality comparison over instances */ + if(cell_1 == cell_2){ + /* Evaluates to True */ + } + + +

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

+ + + #include <string.h> + #include <stdlib.h> + #include <stdio.h> + + // maximum legal index into the symbol list + #define LIST_EXTENT 3 + + typedef const char *Instance; + typedef struct{ + Instance *head; + Instance *tail; + Instance *extent; + } List; + + static List SYM_LIST = {NULL ,NULL ,NULL}; + + Instance make_list(const char *name){ + size_t size = LIST_EXTENT + 1; + SYM_LIST.head = (Instance *)malloc( size * sizeof(Instance) ); + SYM_LIST.tail = SYM_LIST.head; + SYM_LIST.extent = SYM_LIST.head + LIST_EXTENT; + *SYM_LIST.head = strdup(name); + return *SYM_LIST.head; + } + + Instance make_symbol(const char *name){ + if(!SYM_LIST.head) return make_list(name); + + Instance *pt = SYM_LIST.head; + while(1){ + if( strcmp(*pt ,name) == 0 ) return *pt; + + if(pt == SYM_LIST.extent){ + fprintf(stderr ,"symbol list overflow for %s\n" ,name); + return NULL; + } + + if(pt == SYM_LIST.tail){ + *++SYM_LIST.tail = strdup(name); + return *SYM_LIST.tail; + } + + pt++; + } + } + + int main(){ + Instance a = make_symbol("a"); + Instance b = make_symbol("b"); + Instance c = make_symbol("c"); + Instance d = make_symbol("d"); + Instance e = make_symbol("e"); // overflows table + + Instance *pt = SYM_LIST.head; + Instance *pt_tail = SYM_LIST.tail; + while(1){ + puts(*pt); + if(pt == pt_tail) break; + pt++; + } + + if(e == NULL) printf("e is NULL\n"); + } + + +

Property

+ +

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

+ +

Dictionary and reference

+ +

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

+ +

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

+ +

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

+ +

A Turing Machine tape cell

+ +

+ A cell is the square from Alan Turing's 1936 paper Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265.. Mathematically, a cell is a referencable distinct identifiable set, with one to three property members depending on the type of cell. +

+ +

+ A leftmost cell is a set of two properties named 'right neighbor' and 'data'. A rightmost cell is a set of two properties named 'left neighbor' and 'data'. An interstitial cell is a set holding three properties: a 'left neighbor', a 'right neighbor', and 'data'. While an island cell owns a single compulsory property, that of 'data'. +

+ +

+ The value of a neighbor property is a non-null single reference to a cell. The value of a data property is strictly an instance of an alphabet symbol, or alternatively, an instance of the empty symbol. +

+ +

Tape

+ +

+ A tape is a set containing exactly one leftmost cell and an infinite number of interstitial cells. For each cell in the set, called cell A, if cell A has a right neighbor that is cell B, then cell B's left neighbor is cell A. Similarly, if cell A has a left neighbor of cell B, then cell B's right neighbor is cell A. Furthermore, any cell in the set must be reachable by traversing right neighbors starting from the leftmost cell, in a finite number of steps. +

+ +

+ To say that a tape is infinite, and to simultaneously require that any cell can be reached in a finite number of steps, means that after reaching said cell, there will always be further cells to the right. Consequently, though any cell can be reached in finite hops starting at the leftmost cell, a finite traversal of the tape can not visit all of the cells. This seeming contradiction is at the very heart of the definition of the countable infinity in mathematics. +

+ +

+ In conventional computation theory, once a tape is defined, the cell neighbor properties values are fixed. Cells don't move, new cells cannot be added, and cells existing on the tape cannot be removed. This fits the definition of a space, so we can say that a Turing Machine tape has a constant, fixed, linear topology. This permanence of cells matches the reality of hardware memories. On the other hand, it does not track well with general memory containers such as linked lists where destructive operations are often permitted. +

+ +

+ Nor can a cell data property be removed; however, unlike for cell neighbor property values, the cell data property value can be changed while the Turing Machine is running. In fact some people would say this is the whole point of running a Turing Machine. +

+ +

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

+ +

+ The tape is intentionally defined in such a manner that there is no meaning to 'in between' two cells. The head of the machine is always on exactly one cell, with the option of stepping to neighbor cells. Taking a step is an atomic operation; there is no meaning to 'during the step'. Turing Machines are state machines controlled by a clock. A person only asks questions of them when the machine is in a defined state. +

+ +

+ Mathematically, a Turing Machine tape can be expressed as a path graph. However, a tape model and a path graph model imply different ontological contexts. The neighbor property of a Turing Machine tape cell specifically informs a clock driven atomic step function where to place the machine head next. The machine only has defined meaning at the state points on the programmed controller. In contrast, a path graph exists in the wider context of graph theory. A path graph has edges and each edge can be focused on, said to be traversed over, and given general properties. These are things we explicitly excluded in the tape definition. If we were to move the tape from the context of the machine and into the more abstract mathematical context by modeling the tape with a path graph, then we would do so for the purpose of analyzing the tape, which is a higher order and more abstract activity. However, in the current exercise we are not reaching towards the more abstract; rather, we are reaching in the other direction, towards machine architecture. +

+ +

Tape transport unit, TTU

+ +, from which tapes can be mounted and unmounted. Multiple TTUs can be plugged in. Each TTU contains: + +mount/unmount + +
    +
  1. a read/write head
    2. +
  2. a single symbol FIFO read data buffer, written by the TTU, read by the programmable controller
    3. +
  3. a single symbol FIFO status buffer, written by the TTU,, read by the programmable controller
    4. +
  4. a single symbol FIFO command buffer, written by the programmed controller, acted upon immediately by the TTU.
    5. +
+ + +

+ The tape head consists of a reference to exactly one of the tape cells and a set of four functions: read, write, step-left, and step-right. In addition, the tape head can throw an error, left-of-leftmost, if the Turing Machine attempts to step left from the leftmost cell. When stepping, the cell reference in the head is updated based on the neighbor properties of the currently referenced cell. The cell referenced by the head is called the cell the head is on, or more simply, the head cell, or more generally as the indicated cell. +

+ +

+ A person can also say that the head indexes the head cell. This utilizes the classical mechanical definition, where an index is a mark for aligning gears. This physical meaning contrasts with an index integer used for addressing an array. The architectural definition of the Turing Machine developed here relies strictly upon the topological properties of the tape, independent of the definition of Natural Numbers. Addresses, which do rely on Natural Numbers, are discussed further on in this volume. This represents a minor divergence from Alan Turing's original paper, as he took it as a given that numbers naturally paired with the squares. We explicitly establish that pairing only after deriving Natural Numbers using the Turing Machine itself. +

+ + + +

The customer programmed components

+ +

The customer programmed portion of the programmed control consists of:

+
    +
  1. default next state list
    2. +
  2. state dictionary
    3. +
  3. an initial state reference
    4. +
  4. a halt state reference
    5. +
  5. an error state reference
    6. +
+ +

A programmer uses a Natural Number to reference a state. Hence the initial state reference and halt state reference are set to Natural Numbers. It is not required but it is conventional to use 0 as the initial state.

+ +

A next state specifier is a pair consisting of an identifer to be matched as a first of the pair, and a next symbol reference as a next component, where each identifier has the form:

+ + [<TTU_ID>:][<buffer>:]symbol + +

As multiple TTUs can be plugged in, an identifier starts with a TTU id. There are two buffers that on the TTU interface that interface can read, data and status, so that is specified next. Following that is the symbol to be matched. If the TTU_ID field is not present, the colon is also omitted, and the value is taken as 0. If the buffer name is ommitted, the colon is also omitted, and the value is taken as data.

+ +

The default next state list is a list of next state specifier. This list is checked first, i.e. has precedence, over the state dictionary next state list

+ +

Each entry in the state dictionary consists of one TTU command, followed by a next state list.

+ +

The TTU command set consists of:

+
    +
  1. no-op
    2. +
  2. step
    3. +
  3. step left
    4. +
  4. write(x)
    5. +
+ +

Note that the write value, x must be a symbol from either the data alphabet or be the empty symbol.

+ +

The structural portion of the programmed controller:

+
    +
  1. the TTU command set
    2. +
  2. the current state register
    3. +
  3. the reset control line
    4. +
  4. the clock
    5. +
  5. multiple comparators
    6. +
+ +

The comparators are used to used to match the identifier with a the values read from each of the buffers. Note that if the same next state is specified for the same start state, then it is the same as though the identifiers are in disjunction. Also the no-op command to create conjunctive decisions. Hence as a shorthand notation arcs can be labeled with propositions made from the buffer values.

+ +

Upon reset the current state register is written with the initial state. When the current state register is set to the halt state, the machine stops. If no next state is found for a given state, the error state is written to the current_state_register and the machine halts.

+ +

On the rising edge of the clock, the TTU writes the data and status buffers, and the state command is written to the TTU command buffer. On the falling edge of the clock, the TTU completes the state command, and the next state is written to the current state register.

+ +

Here is an example customer defined programmed controller for incrementing a unary number:

+ + + Data alphabet: {s} + States: {0, 1, 2, 3, 4} + Initial state: 0 + Halt state: 3 + Error state: 4 + + State dictionary: + { + 0: n op + s -> 1 + □ -> 2 + 1: step_right + s -> 1 + □ -> 2 + 2: write(s) + * -> 3 + } + + Default next state table: { + status:left-of-leftmost -> 4 + } + + + + + + + + + + + + + + + + + + + + + + +

+ The distinct empty symbol can be any symbol that is excluded from the alphabet. Only instances of alphabet symbols or the empty symbol are permitted to be written to the tape. +

+ +

+ Intuitively, a person might consider that the alphabet symbols are useful while the empty symbol is merely taking up space while waiting to be displaced, in the same manner that a person considers a bookshelf to be empty rather than being full of air. (And if a person puts a bookshelf underwater, is it still empty, or is it full of water?). +

+ +

+ If a physical machine receives power without the reset signal being held, it can land in an illegal state. This is hazardous as the machine might become permanently stuck in a configuration that ignores subsequent reset commands, it might operate unpredictably, or it might even suffer physical hardware damage. To avoid these outcomes, systems are designed to hold the reset line active while the power comes up. Asserting the reset signal, rather than recycling power, is what actually causes a machine to land in a known initial state. Consequently, we must include a reset feature. +

+ +

+ This design assumes that when reset is released, that the machine immediately starts running. This is fine for our purposes, but surely the deluxe model would have a separate 'go' button and the associated logic. +

+ +

+ The tape transport unit, TTU, handles mounting, unmounting, reading, writing, and moving, the tape. In this volume we will talk about stepping the head. This should be interpreted in a relative sense, as a real TTU will move the tape rather than the head. Our machine is designed such that the customer can plug in more than one TTU unit. Each unit has its own read buffer, status buffer, and head. A tape can be mounted or unmounted from each unit. At the election of the operator, the tape can be unmounted from one TTU, shelved perhaps, then unshelved and mounted back on the any TTU, the same one, a different one on the same machine, or a TTU on another machine. +

+ +

+ The constant executor should not be conflated with the Turing Machine program. For a microcode controlled machine, the procedure will be found in microcode memory, and it will be executed as though a program. Each line of the procedure, when read, results in a set of bits being connected to the machine's control lines. Some of those control lines will control what the procedure does, and some will extend out into the data path and be used to configure execution units and gate data on to busses. +

+ +

+ For a hardwired machine, the operation program will be expressed with logic gates and flip flops (single bit memory registers). Whether a machine is microcode controlled, or hardware controlled is a question of implementation. The values on the control lines remain the same independent of those implementation decisions, so those decisions are inconsequential to our architecture discussion. +

+ +

+ The Turing Machine architecture specifies an infinite tape, which can neither be implemented, nor realized. We will introduce a computationally inconsequential modification in a later chapter that causes the tape to be finite. +

+ + +

Machine

+ +

The immutable structural components:

+
    +
  1. a read only empty symbol that is distinct from any symbol in the data alphabet. The examples in this document use the symbol '□'
    2. +
  2. a read only control alphabet for this base model, consisting of the one symbol leftmost
    3. +
  3. a read writable current state reference variable, which points into the custom predefined program controller
    4. +
  4. a fixed hardware halt state comparator
    5. +
  5. a tape transport unit, TTU, from which tapes can be mounted and unmounted. Multiple TTUs can be plugged in. Each TTU contains: +
      +
    1. a read/write head
      2. +
    2. a single symbol FIFO read data buffer, written by the TTU, read by the programmable controller
      3. +
    3. a single symbol FIFO status buffer, written by the TTU,, read by the programmable controller
      4. +
    4. a single symbol FIFO command buffer, written by the programmed controller, acted upon immediately by the TTU.
      5. +
    +
    6. +
+ +

The fixed logic internal to the machine:

+
    +
  1. a constant executor where each step of the procedure can be referenced by number
    2. +
  2. a read/writable/incrementable executor step counter
    3. +
  3. a reset button that activates logic that initializes the machine
    4. +
  4. a read only clock to synchronize control and to cause counting until the halt state is reached
    5. +
+ +

Accessories:

+
    +
  1. tapes, as described in a prior section
    2. +
  2. a Universal Turing Machine package, consisting of the Universal Turing Machine programmable controller and auxiliary alphabet, which comes with tapes containing example programs
    3. +
+ +

Each highlighted term is a short name for the associated item.

+ + + +

Operation logic

+ +

+ The following procedure is embodied as further control logic in the Turing Machine. This procedure is fired upon receiving a step pulse. At the time the procedure is entered, the head is stable upon a cell. We list phases so as to avoid any apparent race conditions. This does not dictate to the designers that the clock must have phases, though that isn't excluded either. +

+ +

Deterministic (Uniplex) programmed control procedure

+ +

Upon each step pulse:

+ +

Phase 1:

+
    +
  1. read the symbol instance indicated by the head into the read data buffer
    2. +
+ +

Phase 2:

+
    +
  1. lookup the current state in the instruction table
    2. +
  2. lookup the current state concatenated with the read data buffer in the next state table
    3. +
  3. lookup the current state in the default next state table
    4. +
+ +

Phase 3:

+
    +
  1. if the current state is found in the next state table, use the retrieved value as the next state. Otherwise, if the current state is found in the default next state table, use the default state as the next state. Otherwise, use the error state as the next state.
    2. +
  2. if an instruction was retrieved from the instruction table, the tape transport executes it. Otherwise, the tape transport executes the default 'no-op' instruction.
    3. +
+ +

Phase 4:

+
    +
  1. write the next state to the current state register
    2. +
  2. controller remains quiescent waiting for the next step pulse
    3. +
+ + +

An alternative: stored program and sequencer

+ +

+ The Universal Turing Machine, proposed by Alan Turing, introduced a profound architectural inversion: relocating the defining state tables from hardwired logic, or manually configured patch panels, directly onto the tape itself. This enables replacing the custom programmed controller with a fixed controller that derives its behavior dynamically from the tape data. Consequently, a single, immutable hardware architecture can simulate the execution of any conceivable Turing Machine. +

+ +

+ In addition, encoding a machine's control logic as parseable data on tape establishes an ontology of analysis, a framework where a machine can analyze another machine to establish some properties the other machine might have. We say 'some' because at least one limitation has been proven. Alan Turing proved that such an analyst cannot in general determine if said other machine has the property that it would halt for any input when run. +

+ +

+ We can optimize this representation. Instead of storing the state tables verbatim, we can list a sequence of instructions directly on the tape. To achieve this, the architecture expands to support two distinct categories of instructions: the physical tape transport instructions we defined previously, and a newly introduced category of control instructions. The programmed controller is then replaced with a fixed hardware controller called a sequencer. +

+ +

+ Because the original state tables allowed for non linear execution paths, the instruction sequence on the tape cannot always execute in a straight line. Therefore, the architect must include at least two control instructions: a halt instruction and a test and branch instruction. The sequencer starts at the first instruction in the program, perhaps at the leftmost cell on the tape, and evaluates it. If it is a control instruction, the sequencer acts upon it directly to alter the flow of execution or stop the machine. Otherwise, if it is a physical instruction for the head unit, the sequencer passes it down to the tape transport. +

+ +

+ Because we have not yet derived Natural Numbers or memory addresses in this architecture, a test and branch instruction cannot jump to a numerical address. Instead, it must operate topologically. A topological branch instruction simply commands the sequencer to scan the tape for a specific target symbol, and resume executing instructions from that physical location. +

+ +

+ As noted in the prior section, an instruction consists of an instruction code and potentially an argument. There are many choices that can be made in instruction set design. Among those choices, almost all will be inconsequential from a computation theoretic point of view, but almost all will introduce strict efficiency trade offs in physical hardware. +

+ + +

Operation logic

+ +

+ In the prior two sections we discussed the configurable part of the Turing Machine control. Here we complete the picture by describing the fixed portion. +

+ +

Setup

+
    +
  1. select and mount a tape
    2. +
  2. push the reset button
    3. +
+ +

Reset

+
    +
  1. step the head left until an 'left of leftmost' error from the tape transport unit, the head will then be on the leftmost cell
    2. +
  2. hit reset on the programmed controller, or the sequencer, depending on which is being used
    3. +
  3. wait until the release of the reset button
    4. +
+ +

Main:

+
    +
  1. evaluate the value of the reset line coming from the reset button
    2. +
  2. if the reset line is true, execute the Reset procedure
    3. +
  3. if the reset line is false, evaluate the halt line coming from the comparator
    4. +
  4. if the halt line is true, freeze execution until reset is asserted, then return to step 1
    5. +
  5. if the halt line is false, send a step pulse to the programmed controller (or sequencer) on each clock tick
    6. +
+ +

+ A person can read this procedure with the caveat, "if we could realize such a machine, this is what we would do." Later, these directions can be modified and applied to the machine variation that has an expanding tape. +

+ +

+ To start the machine we must first select a tape. Common choices are an empty tape, a tape with data on it the machine is to decide matches a given language pattern, or a tape with a Turing Machine on it to be analyzed. After the tape is selected it is mounted on the Turing Machine, then the reset button is hit. +

+ +

+ After the reset button is released, the machine begins stepping. If the program is a computation, the machine will eventually halt. If the machine eventually halts, then we know the associated program was a computation. Otherwise we do not know. Any amount of time we wait where the machine has not halted, we will not know that it will ever halt. Hence, we cannot in general use 'running a Turing Machine' as a means to determine if a given program is computational. (We could instead try to answer the question 'is it computational' through analysis, but there too, Turing has shown that in general that will not work either.) +

+ +

Operation logic steps, programmed controller steps, and head steps

+ +

+ In common books and papers about the Turing Machine, a step is defined as one step of the programmed controller, i.e. one pass through the four phase procedure given above. Decider proofs ask if the comparator will match the halt state within a finite number of steps. Time complexity proofs take a formulation of step count to reach the halt state, parameterized against the size of the input, and report the order of the highest term as it is asymptotically dominant. Hence we speak of constant, linear, polynomial, and exponential time complexity algorithms. A similar method of analysis, that of memory usage with step count, parameterized against input size, is used for space complexity. +

+ +

+ For a real machine, the step pulse will be derived from the machine clock. The clock will have a constant period, so there is a constant duration of time that will be the same for each pass through the execution procedure. Thus, if we replace the step count with a count of clock ticks, we will get the same decider and complexity results as we would have from step counts. This fits the definition we have been using for inconsequential. +

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

+ Given that we have an architectural definition for a Turing Machine, and will modify this in a later chapter to define a realizable Turing Complete architecture, it is possible to invert the foundation of mathematics. Instead of mathematics preceding computation, we posit that given a Turing Machine exists, all of mathematics is an interpretation of what can be done with it. +

+ +

+ We begin by defining the tape cell as a location in a physical memory, which provides us with arrays of charge configurations. +

+ +

+ We then define the symbol in computational terms, as done in the prior section. This begins with memory addresses, represented as charge arrays, acting as primitive symbols, and extends to the symbol factory, copy operations, and instance comparison. +

+ +

+ Logic is then defined on top of relay switch logic, as Shannon and others have already done. A machine that requires all inputs to be the '1' symbol to produce a '1' symbol output is a conjunction machine, and so forth. +

+ +

+ On top of this we can define the Peano Machine, a counter, and then use that machine as the definition of Natural Numbers. +

+ +

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

+ +

+ An axiomatic proof is then a decider that is built up from subroutine calls to the axioms. We might then quantify over all possible compositions of our subroutines in analysis and ask if it is possible that a contradiction decider would return Y or N. +

+ +

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

+ +

+ With the language of Computational Naturalism it is possible to restate every statement ever made by any mathematician; we might say that the mere fact that a mathematician was able to state something qualifies its membership into Zermelo's S set. +

+ +

+ Given our knowledge that a universal halting problem analyzer that decides if a Turing Machine program halts does not exist, it is desirable to have rules that guide our writing only Turing Machine programs that are known to halt. This can be done through construction, as proposed by Russell, or through axioms of separation, mapping, and choice, as proposed by Zermelo and others. But then we know from the completeness and correctness theorems, that when such guiding rules are applied, there will exist Turing Machine programs that do halt, but whose definition cannot be constructed, nor surmised using the said axioms. +

+ +

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

+ + + Computational Analysis + +

Definition

+ +

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

+ +

+ In computation theory, computational analysis is defined as the static evaluation of a formal system or machine definition to deduce its absolute boundaries and properties. This process remains entirely distinct from dynamically executing the machine to yield a computed result. +

+ +

+ This analytical perspective has been present from the very beginning of the field. Alan Turing's formulation of the halting problem relies explicitly on one machine examining another. To properly evaluate the limits of this analytical capacity, the examining machine must necessarily be given definitions of programs that loop infinitely. Consequently, the foundational proofs of computer science formally establish non computational programs as legitimate objects of analytical study. +

+ +

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

+ +

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

+ +

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

+ +

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

+ +

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

+ +

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

+ +

+ As an analyzer does not run the machine being studied, 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

+ +

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

+ +

+ 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 commands: (step), (step-left), (read), and (write symbol). In the first order, evaluating these commands 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: +

+ + + (defparameter *five-ast* + '(progn + (write s) (step) + (write s) (step) + (write s) (step) + (write s) (step) + (write s) (step) + )) + + +

Similarly, the AST for the number 3:

+ + + (defparameter *three-ast* + '(progn + (write s) (step) + (write s) (step) + (write s) (step) + )) + + +

+ If we were to dynamically evaluate these ASTs in the first order, the 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) command with an inverted pair: a (step-left) command followed by writing the empty symbol (write □). +

+ + + (defun invert-direction (cmds) + (cond + ((null cmds) nil) + ( + (and + (cdr cmds) + (equal (first cmds) '(write s)) + (equal (second cmds) '(step))) + (append + '((step-left) (write □)) + (invert-direction (cddr cmds)) + )) + ( + t + (cons + (first cmds) + (invert-direction (cdr cmds)) + )))) + + (defun primitive-compose-subtract (ast-a ast-b) + (let + ( + (body-a (rest ast-a)) + (body-b (rest ast-b)) + ) + `(progn + ,@body-a + ,@(invert-direction body-b) + ))) + + +

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

+ + + (defparameter + *primitive-five-minus-3-ast* + (primitive-compose-subtract *five-ast* *three-ast*) + ) + + ;; *primitive-five-minus-3-ast* evaluates to: + ;; '(progn + ;; (write s) (step) + ;; (write s) (step) + ;; (write s) (step) + ;; (write s) (step) + ;; (write s) (step) + ;; (step-left) (write □) + ;; (step-left) (write □) + ;; (step-left) (write □) + ;; ) + + +

+ I called this 'primitive' because it is missing the simplification. This sort of simplification is also known as compiler code optimization. Optimizations can be operation specific, or general in nature. Here we will send the primitive composition's body to an analyzer which scans the steps and removes the redundant operations. +

+ +

+ Because of the purity of the Lisp syntax, we are able to present a remedial simplifier example here. A (step) followed by a (step-left) annihilate each other, resulting in zero net movement of the tape head. Similarly, on an initially empty tape, a (write s) followed immediately by overwriting with the empty symbol (write □) annihilate each other. +

+ +

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

+ + + (defun remove-annihilations (cmds) + (cond + ((null cmds) nil) + ( + (and + (cdr cmds) + (equal (first cmds) '(step)) + (equal (second cmds) '(step-left))) + (remove-annihilations (cddr cmds))) + ( + (and + (cdr cmds) + (equal (first cmds) '(write s)) + (equal (second cmds) '(write □))) + (remove-annihilations (cddr cmds))) + ( + t + (cons + (first cmds) + (remove-annihilations (cdr cmds)) + )))) + + (defun simplify-machine (ast) + (let* + ( + (cmds (rest ast)) + (reduced (remove-annihilations cmds)) + ) + (if + (equal reduced cmds) + ast + (simplify-machine `(progn ,@reduced)) + ))) + + + +

After giving the difference program to the simplifier, we get:

+ + + (defparameter + *simplified-five-minus-3-ast* + (simplify-machine *primitive-five-minus-3-ast*) + ) + + ;; *simplified-five-minus-3-ast* evaluates to: + ;; '(progn + ;; (write s) (step) + ;; (write s) (step)) + + +

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

+ +

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

+ +

+ 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 divide, say 6/0, the machine will not reduce. It will return a second order value: +

+ + + (divide 6 0) + + +

Now consider the compiler optimization like simplification of this expression:

+ + + (divide (divide 6 0) (divide 3 0)) + + +

The result will be:

+ + + (multiply 2 (divide 0 0)) + + +

+ There is no special help here. Hence, (divide 0 0) remains as an error flag. +

+ +

+ The divide machine cannot be run to produce a value, as any value from the field assigned to it would lead to contradictions. Stated more precisely, for x \cdot y = q operations, when given an x and a q value, there is only one possible y value, and it can be recovered with q/x. However, when x is zero, and only when it is zero, q is solely determined by x independent of y, so y is ignored; it could be any value. There is no way to recover it from q/x. +

+ +

Evaluating and Extending

+ +

+ When a machine is 1) programmed to perform a function f, 2) has its tape initialized with a constant input value, say t (which can be a vector of values), and 3) is then run, writing the result f(t) and halting; we say that the run evaluates the function at t. +

+ +

+ When an evaluator erases the input and leaves only the result in its place, we say it is a substitution evaluator. It is an inconsequential modification to add multiple tapes each with their own tape head to a Turing Machine, so it is possible that an evaluator will have a dedicated tape for the input, a dedicated tape for the output, and have zero or more additional tapes for scratch work. In which case, instead of substitution, one tape is mounted as an input, the machine is run until it halts, and then separately the result tape can be unmounted to potentially be used in a downstream computation. +

+ +

+ In a variation of analytical evaluation, we can instead mount an initial value for a function, and call a machine to repeatedly extend the function. To state this more precisely, when a machine tape is given the initial value of f(t_i) on its input tape, and then when run until it halts having written the result f(t_{i+1}) to the tape, we say that running the machine extends the function. Typically extension machines are designed so they can be used recurrently to extend the function indefinitely, thus producing a sequence of function values, f(t_0), f(t_1), f(t_2), \ldots. +

+ +

+ The difference between adjacent function values in the above sequence is called the first finite difference. The forward first difference is defined as: + \Delta_i = f(t_{i+1}) - f(t_i). + While the backwards first difference is + \Delta_i = f(t_i) - f(t_{i-1}). + If 'forward' or 'backwards' is not specified, then the difference is taken to be 'forward'. Hence, extending a function is identical to adding the first difference. Thus a sequence of function values implies a sequence of first differences. +

+ +

+ A second difference can be defined as the difference between two adjacent first differences. A second difference can be added to a prior first difference to create the next first difference, which could then be added to a prior function value to extend the function to its next value. This pattern can be extended to any number of levels. +

+ +

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

+ +

+ Let us construct a forward difference pyramid for the polynomial f(t) = t^2. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Count (t)f(t) = t^21st Diff (\Delta^1)2nd Diff (\Delta^2)
0012
1132
2452
397
416
+ +

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

+ +

+ Here is the sequence of tape states as the machine is repeatedly called to extend the function from its initial conditions at t = 0. During each step, the machine adds \Delta^1 to f, and \Delta^2 to \Delta^1, as there is no \Delta^3, it is taken to be zero, so \Delta^2 is merely copied down. +

+ + + Initial Tape (t=0): [0, 1, 2] + Call 1 (t=1): [1, 3, 2] + Call 2 (t=2): [4, 5, 2] + Call 3 (t=3): [9, 7, 2] + Call 4 (t=4): [16, 9, 2] + + +

+ For Call 1, the input tape is the Initial Tape. In Call 1 the machine will take the function value on the input tape, 0, and add the first difference, 1, writing the result 1, to the result tape. The machine will then continue on and take the first difference on the input tape, 1, and add the second difference on the input tape, 2, writing the result first difference to the result tape, 3. Then finishing up, the machine will not find a third difference on the input tape, so it will copy the second difference found on the input tape as the second difference for the result tape. +

+ +

+ For Call 2, the input tape is the result tape from Call 1. Execution then proceeds identically to Call 1. This pattern repeats for all successive calls. A person can see the values of t^2 as the first number on each result tape. Any polynomial can be computed in this manner, and the only ALU required is an adder that is also capable of subtraction. +

+ +

Lemma: Only row 0 is needed

+ +

+ The extension function can be called any number of times when the initial tape is identical to row 0 of the table of finite differences. No other row is needed from the table of finite differences. +

+ +

+ This follows from the mechanical procedure given above for computing the next row of the table from any given row. +

+ +

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

+ +

+ Let the extent refer to the maximum index for accessing a component of a vector; the extent is often denoted as \omega. Performing extensions to calculate the function value at call \omega makes use of the initial tape up to index \omega, or as many nonzero values as are available up to that extent. +

+ +

+ To make this precise, let us define the difference vector at call k as D_k. The components of this vector are D_{k, 0}, D_{k, 1}, \ldots up to the maximum available difference. The first component, D_{k, 0}, is the function value itself. The component D_{k, 1} is the first difference, and so on. +

+ +

+ Thus, this lemma claims that to compute D_{\omega, 0}, the highest component index accessed from the initial tape vector D_{0, i} will be i = \omega. +

+ +

+ Note that to compute the D_{k, 0} result by the mechanical procedure given above requires adding the input tape first difference to the prior difference. That is, D_{k, 0} = D_{k-1, 0} + D_{k-1, 1}. Hence we see immediately the lemma holds for the first call where k = \omega = 1. +

+ +

+ For an arbitrary k value we discovered that the highest index required of the D_{k-1, i} vector is i=1. + The value D_{k-1, 1} is computed from our mechanical procedure as + D_{k-1, 1} = D_{k-2, 1} + D_{k-2, 2}. Given we already know that to compute the value merely requires the prior value and first difference, we find that the largest index needed from vector D_{k-2, i} is 2. +

+ +

+ There is a strict linear progression here. The computation of any component D_{k, i} inherently requires D_{k-1, i} and D_{k-1, i+1}. Therefore, each step backwards in time k expands the required index i by exactly one. By induction, computing the base value D_{\omega, 0} at call \omega requires tracing back \omega steps to the initial tape at k=0, which forces the maximum accessed index to be 0 + \omega = \omega. Thus, the highest required component from the initial tape is D_{0, \omega}. +

+ +

+ The exact algebraic composition of this mechanical expansion is formalized by Newton's calculus of finite differences Isaac Newton formalized this interpolation method in 1675, later published in his Methodus Differentialis (1711). For a comprehensive foundational treatment, see George Boole, A Treatise on the Calculus of Finite Differences (Cambridge: Macmillan and Co., 1860), Chapter II.. Instead of executing the machine incrementally, a person can calculate the function value at call \omega directly as a linear combination of the initial tape components using Newton's forward difference formula: +

+ +

+ D_{\omega, 0} = \sum_{j=0}^{\omega} \binom{\omega}{j} D_{0, j} +

+ +

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

+ +

+ D_{0, n} = \sum_{k=0}^{n} (-1)^{n-k} \binom{n}{k} D_{k, 0} +

+ +

+ As a consequence of this lemma, we know that for any finite number of calls, i.e. finite \omega, that a finite prefix of D_0 is used. +

+ +

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

+ +

+ A polynomial of degree \omega is defined by a highest order term a_\omega t^\omega. The first forward difference operator, \Delta f(t) = f(t+1) - f(t), inherently cancels the t^\omega term. The binomial expansion of (t+1)^\omega yields t^\omega as its leading term, which subtracts out, leaving a new polynomial of exactly degree \omega - 1. +

+ +

+ Taking successive finite differences reduces the degree of the polynomial by exactly one at each step. Consequently, the \omegath difference evaluates to a constant, and the next difference evaluates to exactly zero. +

+ +

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

+ +

+ If an initial difference vector D_0 has an extent of \omega, the sequence of function values generated by the machine corresponds to a polynomial of exactly degree \omega. A person can demonstrate this by algebraically recovering the polynomial constants, a_i, directly from the initial tape components, D_{0, i}. +

+ +

+ Consider an extent of \omega = 0, forming a polynomial of degree 0, f(t) = a_0. Evaluating at t = 0 yields f(0) = a_0. Because the machine's initial value is D_{0,0}, a person establishes a_0 = D_{0,0}. +

+ +

+ When a person extends the extent to \omega = 1, the next term is added to form f(t) = a_0 + a_1 t. The first forward difference at t = 0 is D_{0,1} = f(1) - f(0) = (a_0 + a_1) - a_0 = a_1. Therefore, a_1 = D_{0,1}. Note that the addition of the linear term did not change the evaluation at t = 0; the a_0 constant remains firmly anchored to D_{0,0}. +

+ +

+ Extending to \omega = 2, the polynomial becomes f(t) = a_0 + a_1 t + a_2 t^2. The second difference at t = 0 is calculated as D_{0,2} = f(2) - 2f(1) + f(0). Substituting the polynomial yields D_{0,2} = (a_0 + 2a_1 + 4a_2) - 2(a_0 + a_1 + a_2) + a_0 = 2a_2. Thus, a person recovers a_2 = D_{0,2} / 2. The lower coefficient then adjusts to a_1 = D_{0,1} - a_2. +

+ +

+ Continuing to \omega = 3, the polynomial is f(t) = a_0 + a_1 t + a_2 t^2 + a_3 t^3. Evaluating the third difference D_{0,3} isolates the highest order term, yielding D_{0,3} = 6a_3. This allows immediate recovery of the highest constant: a_3 = D_{0,3} / 6. +

+ +

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

+ +

+ To observe the structural integrity of this progression, a person can array these relationships into a system of equations mapping the initial tape to the polynomial constants: +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
DifferenceEquation
D_{0,0}= a_0
D_{0,1}= a_1 + a_2 + a_3 + \ldots + a_\omega
D_{0,2}= 2a_2 + 6a_3 + \ldots
D_{0,3}= 6a_3 + \ldots
\ldots\ldots
D_{0,\omega}= \omega! a_\omega
+ +

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

+ +

+ To observe the formal mechanics of this progression, a person can alternatively array these relationships into a matrix equation mapping the polynomial constants, a_i, to the initial tape differences, D_{0,n}. The coefficients of this transformation are defined by the Stirling numbers of the second kind, denoted S(i,n): +

+ + + \begin{bmatrix} D_{0,0} \\ D_{0,1} \\ D_{0,2} \\ \vdots \\ D_{0,\omega} \end{bmatrix} = + \begin{bmatrix} + 0! S(0,0) & 0! S(1,0) & 0! S(2,0) & \cdots & 0! S(\omega,0) \\ + 0 & 1! S(1,1) & 1! S(2,1) & \cdots & 1! S(\omega,1) \\ + 0 & 0 & 2! S(2,2) & \cdots & 2! S(\omega,2) \\ + \vdots & \vdots & \vdots & \ddots & \vdots \\ + 0 & 0 & 0 & \cdots & \omega! S(\omega,\omega) + \end{bmatrix} + \begin{bmatrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_\omega \end{bmatrix} + + +

+ For any extent \omega, the final row of this strictly upper triangular matrix again simplifies to D_{0,\omega} = \omega! a_\omega. +

+ +

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

+ +

+ a_i = \sum_{n=i}^{\omega} \frac{s(n,i)}{n!} D_{0,n} +

+ +

+ Thus, extending this procedure \omega times definitively recovers the constants for exactly a polynomial of degree \omega. +

+ +

+ This mechanical recovery of standard polynomial constants is completely analogous to Newton's interpolation formula Ibid.. Instead of resolving the standard constants a_i through an upper triangular matrix, a person can construct the polynomial directly by treating the initial tape components as the exact coefficients for a basis of binomial terms: +

+ +

+ f(t) = \sum_{n=0}^{\omega} D_{0, n} \binom{t}{n} +

+ +

+ Because the nth binomial coefficient expands into a polynomial of exactly degree n, and the summation is bounded by the finite extent \omega where D_{0, \omega} is definitively nonzero, the constructed function f(t) is structurally guaranteed to be a polynomial of degree \omega. +

+ +

Difference table for an exponential function

+ +

+ Here is the table of finite differences for the function 2^t. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Count (t)f(t) = 2^t1st Diff (\Delta^1)2nd Diff (\Delta^2)3rd Diff (\Delta^3)
01111
12222
2444
388
416
+ +

+ The first difference of 2^t is also 2^t, so row 0 of the table will have an infinite number of values. Fortunately, due to the lemma stating that evaluating call \omega requires an initial tape populated with components 0 through \omega of row 0, exactly those components are needed for the recurrence to proceed. Furthermore, when new values are needed, they are easily computed. A programmer need not store the entire infinite first row of the difference table on a static tape. +

+ +

+ Instead of attempting to write an infinite sequence to a physical tape, a person can encapsulate the generation logic within a dedicated Turing Machine. In the tradition of constructive arithmetic associated with Boehm, this generator machine acts as a virtual tape. When the primary extension machine requires the next difference component, it queries the generator machine, which computes and yields the value on demand. This lazy evaluation strategy elegantly handles functions with infinite difference sequences without exhausting finite memory. +

+ +

Composition of recurrence functions

+ +

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.

+ +

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

+ +

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

+ +

A pole and zero cancellation

+ +

+ Here we circle back to the division by zero problem, though this time while extending functions. Let us begin with the two functions, f(t) = 2^t - 32 and g(u) = u - 15. Both have D_0 vectors, though the one for the exponential function is defined by a machine rather than by a value on a tape. +

+ +

+ We cannot do function based arithmetic on these until we synchronize them. Suppose that for each call of the f machine, there will be three calls to the g machine. So we can make a new machine that is called once, each time f is called, g(t) = 3t - 15. +

+ +

+ Now suppose we want to express the quotient of these two functions. +

+ + + h(t) = \frac{f(t)}{g(t)} = \frac{2^t - 32}{3t - 15} + + + Figure singularity plot + + +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Count (t)Quotient (f(t)/g(t))1st Diff Ratio (\Delta^1 f(t) / \Delta^1 g(t))
031/151/3
130/122/3
228/94/3
324/68/3
416/316/3
5(divide f(5) g(5))32/3
632/364/3
796/6128/3
8224/9256/3
9480/12512/3
+ +

+ The quotient machine, (divide f(5) g(5)), is no more representative of the value we expected here, than was (divide 0 0). However, as we have the whole program, we could pass it to a L'Hôpital evaluator and get a value back. But I am wondering if we can't design function extension form that extends to the value and beyond without any hiccups, as most apparently there is a value to extend to. +

+ +

+ I included the first difference along with the evaluation results in the table above. When building a first difference table an interesting thing happens at the singularity, the first difference and the function itself coincide, note calls 4 and 5. This makes sense because \Delta f(4) = f(5) - f(4), which becomes \Delta f(4) = 0 - f(4), and the same happens to g in the denominator, so the signs cancel. Note also \Delta f(5) = f(6) - f(5), which becomes \Delta f(5) = f(6) - 0. +

+ +

Ostensibly it looks like we have happened upon a discrete version of L'Hôpital's rule, that we merely use the first difference quotient instead of the function quotient at the singularity. But alas, the coincidence occurs at h(4) rather than at h(5). For the second coincidence, we find h(6) as the 5th first finite difference. In neither case did we learn anything about the value of h(5). +

+ +

+ Perhaps if we were performing nonstandard analysis, and extending by increments of epsilon in the domain at each step, the nonstandard analysis naturalization function would find that the differential value can be used as the value at the singularity. But here we are discussing finite differences H. Jerome Keisler, Elementary Calculus: An Infinitesimal Approach, 2nd ed. (Boston: Prindle, Weber and Schmidt, 1986).. We are not doing a local analysis here so as to derive a principle, but rather are trying to evaluate a function in the macro view. +

+ +

+ So then, perhaps we set the value at the singularity to x build out the difference table, then solve for x? +

+ + Figure with x variable. + + +

+ As Newton pointed out, we can know the differences on the D_0 row of the table from the quotient function: +

+ + + D_{0,n} = \sum_{k=0}^n (-1)^{n-k} \binom{n}{k} \frac{f(k)}{g(k)} + + +

+ For k=5 the difference evaluates to be (divide 0 0), as it did for the quotient, and it also fails for all values above k=5 due to the summation. So we can not use this to solve for x. +

+ +

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

+ + + T = \frac{32 \ln(2)}{3} + + +

The resulting D_0 vector for the quotient is:

+ + Figure D_0 h(t) + + Figure D table for h(t) + +

+ I find it fascinating to watch the transcendental difference values march down the table, then all cancel out after h(5) is generated. +

+ +

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

+ + +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Count (t)Direct Evaluation (f(t)/g(t))Extended Quotient Vector (H(t))
031/1531/15
130/1230/12
228/928/9
324/624/6
416/316/3
5(divide 0 0)\frac{32 \ln(2)}{3}
632/332/3
796/696/6
8224/9224/9
9480/12480/12
+ +

Chapter discussion

+ +

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

+ + + f(t) = t^3 + + +

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.

+ +

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

+ +

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 createing 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 \delta out, over the domain of the input. Then instead of back propagation of precision requests at run time, there is a back propagation of precision requirements at analysis time. This approach was used on the AMD K5 processor transcendental microcode to guarantee that computations yielded specified accuracy. The method is also well suited for setting the bus widths for application specific processors, because the analysis step can occur once at design time. Thomas Walker Lynch, A. Ahmed, M. Schulte, T. Callaway, and R. Tisdale, "The K5 Transcendental Functions," Proceedings of the 12th IEEE Symposium on Computer Arithmetic, 1995. DOI: 10.1109/ARITH.1995.465368. Thomas Walker Lynch, "Numerical Analysis of Computer Approximations," September 2018. DOI: 10.13140/RG.2.2.10906.49601. License CC BY 4.0. https://www.researchgate.net/publication/329402329_Numerical_Analysis_of_Computer_Approximations. +

+ +

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

+ +

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

+ +

This section reviewed finite difference methods as a means to implement function extensions. A person should notice that finite differences are one among many methods for extending functions, and they are not always the best choice. In modern computing it is not common to implement function extensions. Rather it is more common to increment a value across a domain, while completely repeating the evaluation for each new domain value, for example when computing values to place on a plot. However, independent of their importance in applied computing, function extension and difference methods are of theoretical importance for analysis, particularly when applied to nonstandard analysis. These speak to the thesis of computational naturalism in the derivation of mathematics, rather than as a proposed method of implementing computational programs. +

+ + + Address + + +

Unary Representation address

+ +

+ A person can define a Turing Machine that is identical to the recursive definition of Natural Numbers as given by Peano. Giuseppe Peano, Arithmetices principia, nova methodo exposita (Turin: Fratres Bocca, 1889). If a person were to run the Natural Number Machine and observe as it writes to the tape, that person would watch as the Natural Numbers are printed one after another: '·s·ss·sss·ssss· ...'. Here '·' represents zero, and 's·' represents one, etc. Because the Natural Number Machine never halts, the machine cannot be used to initialize a tape, but an analyzer can evaluate the machine to make conclusions about what it would write if it were run. +

+ +

+ In contrast, a function extension version of the Natural Number sequence generator can be run. The function extension machine would be given as input a prior function extension result, or an initial empty tape. It would then modify the tape to contain the next Natural Number, as per the sequence that the Natural Number machine would write, if it could be run. This is accomplished through two subroutine calls: find_empty and increment. The find_empty machine checks the symbol under the head. Upon finding it is not the empty symbol, the machine steps right and checks the next cell, repeating until it finds the empty symbol, whereupon it halts. The increment machine then writes an 's' onto the tape and halts. Recurrent calls to the Natural Number extender then produce a sequence of result tapes: [], [s], [ss], …. Similarly, a programmer can write a machine called decrement, though the programmer must note that decrementing can return the left-of-leftmost symbol. +

+ +

+ To say that Natural Number A is smaller than Natural Number B is to say that A would occur on the Natural Number Machine tape to the left of B, if the machine were run. Conversely, if B were said to be greater than A, that would mean B occurs further to the right. It is a simple matter for a programmer to write a decider machine for this. The decider is given two input tapes for the two numbers to compare, and it keeps a head on each. It then steps forward until neither head has an 's' under it. If empty symbols are found simultaneously on both tapes, then the two numbers are equal; otherwise, the number with an empty symbol under the head is the lesser number. +

+ +

+ As such, a person can assign a Natural Number to each cell of a given tape by using a mechanical procedure. Given a machine, say P, and an address machine, say A_P, each time P is stepped right, a call is made to run increment on A_P. Similarly, each time P is stepped left, a call is made to run decrement on A_P. In this manner the tape on A_P will always hold the address that machine P's head is on. +

+ +

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

+ +

+ An address space is a set of addresses for contiguous cells. The tape's address space is the set of addresses for all the cells on the tape. Typically the address of 0 is given to the leftmost among the contiguous cells. +

+ + +

Binary Arabic representation address

+ +

+ Would it be computationally consequential if binary Arabic representation were used instead of unary for addresses? For unary representation each increment was constant time, but with 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? +

+ +

+ For this discussion, the Arabic representation address is variable precision, so it will grow as the count becomes larger. The empty symbol will serve as the terminator. +

+ +

+ For Arabic_increment, the machine reads the cell under the head; upon finding a 0 or the terminator, it writes a 1 and halts. Upon finding a 1, it writes a 0, steps right, and repeats the procedure. +

+ + + increment: + a = TTU.read() + if a == 0 or a == □: + TTU.write(1) + halt + TTU.write(0) + TTU.step() + goto increment + + +

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.

+ +

+ Each row shows an input tape, and actions taken to write the result tape. For any given row, the result tape is the same as the input tape on the next row down. The table lists 7 increments, which is sufficient to reach the maximum count that can be held by a 3 bit counter. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
inputactioncost (steps)
0write 1, halt (result is maximum 1 bit count)2
1 write 0, step, write 1, halt4
01write 1, halt (result is maximum 2 bit count)2
11write 0, step, write 0, step, write 1, halt6
001write 1, halt2
101write 0, step right, write 1, halt4
011write 1, halt (result is maximum 3 bit count)2
111
+ +

+ The number of programmable controller state transition steps required to reach a maximum 1 bit, 2 bit, and 3 bit count are: [2, 8, 22]. Note these are cumulative. The three bit maximum count cost includes that of the two bit maximum count cost, etc. Each maximum count is exponentially larger, so a better measure is the average cost per step: [2/1, 8/3, 22/7] = [2, 2.667, 3.143] +

+ +

+ For an n bit counter, the sequence of costs follows a pattern. Half of the increments evaluate one bit (costing 2 steps), a quarter evaluate two bits (costing 4 steps), an eighth evaluate three bits (costing 6 steps), and so forth, over the 2^n - 1 increments required to reach the maximum n bit count: +

+ + \sum_{k=1}^{n} 2k \cdot 2^{n-k} = 2^{n+2} - 2n - 4 + +

+ To find the average cost per increment to reach each maximum, an analyst divides by the total number of increments, which is 2^n - 1: +

+ + \text{Average Cost} = \frac{2^{n+2} - 2n - 4}{2^n - 1} = \frac{4(2^n-1)+4-2n-4}{2^n-1} + +

+ This simplifies algebraically to: +

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

+ +

+ Consequently, maintaining an 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 model used here to define an address is analogous to keeping a pointer into memory. Each step then increments or decrements the pointer. Conventional processors do the converse of the Turing Machine model presented here. For a processor, the address is the base object, while the head location is what is implied by the address. On processors, pointers will be one word in width. In small geometries where computation element delay dominates, two operand adders tend towards logarithmic complexity evaluation times against bit width, and the constants are small. Because of this, it is practical to perform word width addition operations atomically in one machine cycle. In fact, for some machines, the adder time likely sets the clock period. Such an adder will be used for address arithmetic; consequently, a programmer cannot arrange a program to expose aliasing in the address increment time to the real world. It remains a theoretical observation. +

+ +

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

+ +

+ Direct address decoding operates independently of reference locality. This fundamentally differs from a Turing Machine head, which incurs a linear computation cost strictly proportional to the distance traveled. However, direct decoding is only the base of the memory hierarchy. +

+ +

+ It is possible that decoding occurs separately in a row and column manner, and changes in the lower bits of the address walk a buffered row that was found in a prior access. This makes access to neighbor cell addresses within a row a low expense operation. However, this depends on memory implementation. One layer up, it is common for memory to be made of interleaved banks, so neighbor access that remains in the leaf collection is generally faster than that which requires fetching a new leaf set. +

+ +

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

+ +

+ Memory accesses into the processor local memory file are even faster. If locality of reference, even in an abstract sense, remains tight, then memory cells can be accessed in a minimal amount of time. +

+ +

+ For programs with large memory footprints and sparse memory access patterns, the dominant factor becomes the virtual memory subsystem. Here locality again comes into play as the translation lookaside buffer provides stateful location context, and the neighbor relationship between pages is sometimes taken into account for performance reasons. However, once a program starts performing at virtual memory page fetch times instead of cache access, or even local system memory access times, the program is said to be page thrashing, and it becomes very slow. It is also possible for small programs to have memory access patterns that alias against the memory subsystem's heuristics and lead to page thrashing. For a typical system, a programmer can write a small program to demonstrate this. +

+ +

+ In summary then, using 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. +

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Memory TierReal World LatencyScaled DelayScaled Arrival EraHistorical Context
L1 Cache Hit1 ns3 days-0043-03-18Three days after the assassination.
DRAM (Main memory)100 ns300 days-0042-01-09Nearly a year later, during the Liberators' civil war.
NVMe SSD Page Swap15 µs45,000 days0080123 years later, exactly as the Colosseum is completed in Rome.
SATA SSD Page Swap100 µs300,000 days0778821 years later, during the reign of Charlemagne and the Frankish Empire.
Magnetic HDD Page Swap10 ms30,000,000 days82092Tens of thousands of years in the future, long after current human civilizations are dust.
+ +

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

+ + + Area and partitioning + +

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

+ +

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

+ +

Head partition

+ +
    +
  1. The left side: The finite set containing all of the cells to the left of the head cell.
    2. +
  2. Head: the head cell.
    3. +
  3. The right side: the infinite set containing all the cells to the right of the head.
    4. +
+ +

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

+ +

Leftmost/remaining partition

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

Active area partition

+ +

+ A nonempty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: +

+ +
    +
  1. The left empty tail: if the leftmost cell of the tape is an alphabet cell, there is no left empty tail. Otherwise, it consists of the leftmost cell and the empty cells, if any, to the right of the leftmost cell, up to, but not including, the first alphabet cell.
    2. + +
  2. Active area: a finite area for computational problems, containing the cells extending from the leftmost alphabet cell up to and including the rightmost alphabet cell. It is possible that the leftmost alphabet cell and the rightmost alphabet cell will be the same cell.
    3. + +
  3. The right empty tail: the infinite set extending from the right neighbor of the rightmost cell of the active area, extending rightward.
    4. +
+ +

+ A noncomputational tape is one that cannot be initialized by a Turing Machine, but can still be surmised to exist, perhaps in analysis due to its properties. The empty tape is an example. The tape holding the Natural Numbers is another example. For noncomputational tapes that have the property that the active area is open on the right, there is no right empty tail. +

+ +

Area implied partition

+ +

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

+ +

The impossibility of recognizing an empty tape

+ +

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

+ +

+ The active area partition of a tape only works for tapes that have at least one alphabet cell. As soon as a machine does its first write of an alphabet symbol, it is known the tape has at least one alphabet symbol. However, what if a tape of unknown status, whether completely empty or containing an alphabet cell, is mounted on a tape machine, and it is desired that the machine recognize if the tape is empty or has an alphabet cell? This is the equivalent problem of looking for the leftmost cell of an active area. +

+ +

+ Recognizing that a tape is empty is generally impossible. Suppose it were attempted, and a machine started scanning the tape rightward from the leftmost cell; for every cell that is discovered to be empty, the machine would have to scan further rightward to check for an alphabet cell. If the tape is truly empty, the recognizer would never stop scanning, so no decision would ever be rendered. +

+ +

The impossibility of recognizing the rightmost cell of the active area

+ +

+ In general, a Turing Machine cannot step across a tape reading cells to recognize the rightmost cell of the active area, or equivalently, the leftmost cell of the right empty tail. Suppose a recognizer attempted this by starting in the active area and stepping right, and the machine discovered an empty cell. The machine would be unable to distinguish between the case of said empty cell being embedded within the active area (meaning more alphabet cells lie further to the right), or the case where said cell is genuinely the leftmost cell of the right tail. To resolve the ambiguity, the machine would be obligated to continue stepping right. Yet, there would never come a time where finding another empty cell would avoid leading back to the exact same case ambiguity, so the machine would forever step right without returning a decision. +

+ +

+ It follows that if knowledge of the end of the active area is needed, this information must be encoded as a message. For example, a special symbol can be reserved in the alphabet specifically to serve as the end of active area marker. Each time a machine steps beyond the current end of active area marker and does a write, it writes the marker in the right neighbor cell, and goes back and erases the old mark. This method is related to communications theory and the science of signaling. Here, the active area marker is an out of band control signal. +

+ +

+ If a tape is written by an initializing tape machine, unmounted, and then mounted on a second analyzing tape machine, the analyzing tape machine is starting with a populated tape. Similarly, a mathematician can, by decree, define an initial tape that holds predefined alphabet symbols. In such a scenario, the initializing machine and the analyzing machine must use a shared communication protocol for signaling the end of the active area. They cannot operate independently or the analyzing machine would not be able to find the end of the active area. This shared protocol then represents information held by a mediator, said mediator could be used at a higher level to write the control for the two machines, or it could be consulted when the two machines are run. Hence, the mediator is either an author, or a service provider, or possibly both. +

+ +

+ By definition, a computation must finish in a finite number of steps. It follows that the active area when a Turing Machine halts a computation will always be finite. Consequently, if a Turing Machine initially starts working with a tape that was computed by another Turing Machine, the length of the input will be finite. Still, that input will be in the active area, so the receiving Turing Machine will need to read control data left on the tape under a common communication protocol to be able to find the bounds of the input area. +

+ +

+ When an input tape is provided as a general mathematical object, either decreed by definition or perhaps abstracted from 'what a Turing Machine computation would produce in the limit of step count', then the input can be either finite or infinite. +

+ +

In band and out of band control

+ +

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

+ +

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

+ +

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

+ +

Virtual cells

+ +

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

+ +

Now imagine we define a Turing Machine such that when it steps right, it steps to the right neighbor area, and when it steps left, if there is a left area, it steps to that, otherwise it returns a left-of-leftmost symbol. The read instruction reads all of the cells in the area, and similarly the write instruction writes them all. Then for this machine the areas are virtual tape cells. +

+ +

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

+ +

Virtual tape

+ +

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

+ +

Various portions of this text have mentioned calling a Turing Machine as a subroutine. This is described as unmounting the tape from the calling machine, mounting it on the subroutine machine, running the subroutine machine until it halts, then unmounting the tape from the subroutine machine, and mounting it back on the calling machine. However, this would be a manual process. To automate the process, we use a Universal Turing Machine. It has the definition for the calling machine and the subroutine machine on its tape. We can add an additional tape to the machine to hold the stack. Then a subroutine call happens much as it does in conventional software. +

+ +

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

+ +

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

+ +

Now suppose defining a Turing Machine that initially has the head on the leftmost cell of a specific area. When step left is called, the tape transport immediately returns the left of leftmost symbol, independent of whether the area is actually at the physical left end of the tape or not. +

+ +

+Now suppose defining a Turing Machine that initially has the head on the leftmost cell of a specific area. When step left is called, the tape transport immediately returns the left of leftmost symbol, independent of whether the area is actually at the physical left end of the tape or not. +

+ +

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

+ +

Partitions on a finite virtual tape

+ +

+ When a Turing Machine operates on a finite virtual tape, the structural logic of the partitions established earlier must be updated to reflect the absolute rightward boundary. +

+ +
    +
  1. For the Head partition and Area implied partition, the right side is no longer infinite. It is a finite set containing all cells extending from the right neighbor of the head (or area) up to the absolute rightmost cell of the virtual tape. If the head (or area) includes the rightmost cell of the virtual tape, the right side set does not exist.
    2. +
  2. For the Leftmost/remaining partition, the remaining area is now a finite set terminating at the rightmost cell of the virtual tape.
    3. +
  3. For the Active area partition, the right empty tail is similarly a finite set extending to the rightmost boundary of the virtual tape. If the rightmost alphabet cell occupies the rightmost cell of the virtual tape, the right empty tail does not exist.
    4. +
+ + Metrics + +

Address defined area

+ +

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

+ +

+ When cells were defined we noted that they were sets, and that these sets had identity and could be referred to. We needed that to be the case so as to build the tape topology using neighbor properties. Had the tape been singly linked, perhaps we could have used the cells to represent themselves in the properties, but when we doubly linked it, a given cell had to appear in two places, as the right neighbor of its left neighbor, and the left neighbor of its right neighbor, so we stipulated the sets as being identifiable. Initially we did not say how they would be identified. This is common in mathematics, but we soon cleared this up by formalizing the concept of a symbol. +

+ +

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

+ +

+ So we now have two means for identifying a feature. One means is to state its address, and the other is to put a tape machine head on it. +

+ +

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

+ +

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

+ +

Distance and extent

+ +

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

+ +

In an analogous manner to defining an address space for a tape, we can define an address space for an area. Accordingly, the leftmost cell of the area is assigned address zero, and the address increments cell by cell going to the right. A finite area will have a finite address space, with the address of the rightmost cell being the largest address in the address space. +

+ +

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

+ +

Length

+ +

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

+ +

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

+ +

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

+ +

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

+ +

How cardinality is computed

+ +
    +
  1. We set Turing Machine P with its head on the leftmost cell of an area. We mount the initial tape, '·', on the A machine.
    2. +
  2. We step P and simultaneously run the A machine. Stepping stops when P reaches the rightmost cell of the area. At this point, the tape on the A machine holds the address space extent.
    3. +
  3. The A machine is run an additional time. The output on the tape is defined to be the cardinality of the address space, aka the cardinality.
    4. +
+ +

Lemma 1, the A machine produces Natural Numbers

+ +

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

+ +

Lemma 2, cardinality is a natural number

+ +

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

+ +

Lemma 3, cardinality is not in the address space

+ +

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

+ +

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

+ +

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

+ +

The apparent contradiction.

+ +

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

+ +

Resolution

+ +

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

+ +

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

+ +

What if extent was used instead of cardinality?

+ +

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

+ +

+ Now here is an interesting result: +

+ + + \aleph_{0} - \aleph_{-1} = 1 + + +

+ Neither machine can be run. However we can compose the two machines, then simplify the composition. When we do so, the ever larger Natural Number machines annihilate each other, and the increment machine remains. The increment machine can be run, so we end up with an output value. +

+ + +

Size

+ +

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

+ + Multiple machines and sharing tapes + +

Suppose we unmount a tape from a halted Turing Machine, say machine T0, and then mount the tape on another Turing Machine as input, say machine T1. Suppose we do this so that machine T1 may calculate the length of the output made by the first machine. When we do this, we run into some problems.

+ +

Firstly, for a conventional Turing Machine, the tape that is mounted on T1 will be infinite, so no computational T1 machine will be able to process it unless there is a message on the tape telling T1 where the end of the input is. For our TTCA machines, if T0 starts with a null tape, and then expands it, and T0 is computational, then at the time T0 halts, the tape will be finite. T1 can then use the continuation of stepping beyond rightmost to know that it has processed all of its input.

+ +

If a Turing Machine does nothing then halts, it will implement an identity relationship between input and output. If we do not want the input given to a machine to 'bleed through', we will have to erase it. A computational TTCA Machine starting from a null tape can only produce finite tapes, so T1 can erase whatever T0 writes to the tape. However, if we are analyzing, instead of running the TTCA machine, we might discover that the tape length would be infinite if the machine could be run. We know that if we pass an infinite tape to a computational TTCA, it would not be able to erase the tape. Fortunately we can derive this fact through analysis and proof without having to run the computational machine to see if it erased the tape.

+ +

Hence if we allow for infinite inputs, we should add an 'erase-to-end-of-tape' command to our machines, so that the computational machines may leave a tape with only their outputs on them. Our erase-to-end-of-tape command will be executed in a single step.

+ +

Once an input tape is mounted, T0 is a computational TTCA machine given a finite tape, its output is a finite tape, and that is taken to be the input for T1.

+ +

T0 is required to provide meta information about the length of the active area. This approach is known as in-band signaling. Because length information is mixed with the data.

+ +

T0 updates a dedicated table where it keeps track of the location of data objects and their lengths. Such a table is called a symbol table, and such a system is called a type system. This is written to a separate tape, or it is inserted at a known location on the main tape. In the case it is written to the front of the tape, the data following will have to be moved when the table grows. In the case it is written at the end of the tape, the table will have to be moved when the data grows. In either case the symbol table entry lengths themselves must also be managed, typically they are either coded into the controller or make use of in band signaling. It is conceivable that a symbol table would describe itself.

+ +

We adopt a convention of maintaining a compact tape. As such we have no embedded empty-symbols in the active area. Then the empty-symbol marks the end of the active area.

+ +

Each machine has two tapes, an input tape, and an output tape.

+ +

A compact area is one that has only alphabet symbols (no empty-symbols). We can extend this concept to say that the density of an area is the ratio of alphabet symbols to empty-symbols.

+ +

The approach we use in modern computing is often the 3nd one listed above, that of the type system. We carefully account for the length of each instance of data. Then we build up each larger instance from smaller ones, and while doing so, we add the lengths of the smaller instances to calculate the length of the larger instance. All programs then specify when they make or compose instances and their types.

+ +

A system for creating the appearance of many tapes over a single tape is called a memory manager or a memory allocation system. It is typically better to use one of these and multiple tape models rather than solving the problem of moving objects around in memory in an ad hoc manner.

+ +

Here is an important question for the TTCA model: is it possible to define a memory manager that creates the appearance of multiple expanding tapes over the top of a single expandable tape? This problem is solved for managing files on a hard disk. However, all current file systems break at some point when pumped. So the question being asked here is equivalent to asking if a files system can be made without such architectural limits. The answer to this is yes, it is possible, as we will see in a later chapter of this book.

+ +

Hence there are multiple conventions we may use for implementing the abstraction of multiple tapes on a tape machine. Multiple tape machine are equivalent in power to one tape machines, but sometimes they are easier to think about.

+ +

Now as we have multiple tapes it is fairly easy to show that having multiple tape machines is equivalent to having one machine. We first view the multiple tapes worked on by the multiple machines as the multiple tapes of one machine. We then compose the state controllers in series, where the halt state of one is the initial state of the next one. Thus we may also conclude that having multiple tape machines is not more expressive than having one tape machine. We may also look at our multiple composed state controllers as one multiplexed controller, and then conclude that having multiple machines will not have an order of speed or space usage advantage.

+ +

The advantage of having multiple tape machines each perhaps having multiple tapes is that sometimes it is easier to think about. It is a method of partitioning the problem.

+ +

Suppose our machines have two tapes where one is called the input tape, and the other tape the output tape. Our procedure for passing tapes between machines will consist of umounting the tape from the source machine, then taking that tape over to the destination machine and mounting it as the input tape.

+ + +

Abstract areas and partitions

+ +

+ A tape area and partitioning can be an abstraction defined by a function rather than merely by a leftmost and rightmost cell. Such areas can have different topologies than those of the base tape. A familiar example for most computer scientists is utilizing software to create the appearance of a two dimensional array over a linear memory. +

+ +

+ Accordingly, suppose there is a three tape Universal Turing Machine gasket machine that holds the definition of a base machine on a first tape. It calls the base machine as a subroutine to access the base machine's tape (the second tape), and it uses its own tape to organize the tape abstraction. Then this outer machine can present to its user a variety of transforms of the base machine's tape. +

+ +

+ As an example, a gasket machine could partition the base machine's tape into two areas, one consisting of the odd addressed cells, and the other of the even addressed cells. Though these two areas consist of noncontiguous cells on the base tape, when viewed through the gasket machine, they appear perfectly contiguous. In this case, each area will have a leftmost cell and remain open on the right. +

+ +

+ When the base machine tape cells behind an abstract area are physically contiguous, we say that the abstract area is compact. In the odd even tape partition example, the abstract areas lack compactness. +

+ + Zero length is a second order concept + +

Suppose we have a Turing Machine that is designed to mark an area based on some property of the symbols.

+ +

Suppose further that starting with the head on the first cell, our Turing Machine will step right zero or more times until it finds a cell that holds a symbol that has the special property.

+ +

Once it finds such a cell it will write an area marker symbol to that cell, step right, and repeat writing area marker cells until it finds a cell that holds a symbol that lacks the area property. At which point the machine halts.

+ +

Once an area is marked, we can go back and run a length measuring machine that counts the sequence of marks.

+ +

However we have a couple of problems, if there is no cell on the tape that has the special property. The area marking machine will step right without halting while looking for the marker. As a second problem, if the all the cells to right of the leftmost area cell, the area marker machine will never halt. +

+ + + +

Now suppose we employ a second order analysis.

+ +

Instead of running our area marker Turing Machine, we examine its definition and the definition of the machine that generated the tape data, to learn if such a machine will ever halt.

+ +

Although we know that it is not possible in general to analyze machines to know if they will halt, or not, it is certainly possible to do so in some cases, and this is one of those cases.

+ +

Upon analysis of our area marking machine we make a startling discovery: inputs exist for which the area marker will never halt.

+ +

In one case, if there is no leftmost symbol with the property that defines the area we are looking for, the marker machine will search forever.

+ +

In the second case, once the area is found, it is open on the right and it never ends.

+ +

We might say that inputs that have no leftmost symbol have an area of zero length.

+ +

This is an abstract concept, because our area marking and area measuring machines will never be run then halt and return a length measure of zero.

+ +

Instead we might arrive at this conclusion that a non-existent area has zero length through inductive reasoning: Say we have an area of length i, and then remove one element from the area, then it has length i-1.

+ +

As we repeat this, then eventually we will have an area of length 1 as discovered by our length assigning machine. Now we remove 1 more element.

+ +

Each time we removed an element before, it made the length smaller by 1, so we reason that 1-1 = 0. The area is now length zero.

+ +

We cannot go any further because there are no more elements to be removed.

+ +

In this case we arbitrarily imagined a longer area. No such longer area was stated in the problem formulation.

+ +

In real world programming, this is the difference between having a container that by implication will hold elements, and lacking the container entirely.

+ +

By applying the limit logic, we have implied that an area exists.

+ +

If running the area maker machine is asserting the existence of such an area, then it makes sense to speak of a zero length area.

+ +

However, if we are not making this assertion, then there is no area so the issue of length is irrelevant. This is a nuanced problem.

+ +

Note, then, that zero length is a second order concept. We cannot mark nor measure it, and given our first order definition for an area, nor can we even represent such an area at a first order.

+ +

There must be some external structure present that implies the existence of the area for zero length to even make sense.

+ +

This insight explains a lot of the pain related to the processing of end cases in computing. It will come up again in this volume when we examine the question of the emptiness of containers, see the section .

+ +

It also explains why loops so often need to be primed or given special case guards, which operates identically to adding a layer of analysis. We will discuss this further later when introducing the first-rest pattern see, .

+ +

It is interesting that non-existence has collided with zero length. This seems to be a contradiction, as something that does not exist should not have any length at all.

+ +

All of this happens at the second order, at the order of analysis. At this order we can make a distinction between an area that we have given a name to, and perhaps a location, as compared to an area for which we have done neither of these things.

+ +

Thus for purposes of second order analysis we will say that an area exists if it has a name or a location, even if it has zero length.

+ +

We will say an area does not exist if it has neither a name or a location. Again, execution of our first order area marking and length machines cannot provide us with any such information.

+ +

Need for the concept of cell

+ +

Let us ask a question, what is it that an address is actually locating? Let us consider this question in the light of an example. Suppose we have the tape sequence of:

+ + + a, b , c, ε, ε, ε … + + +

Now consider that we have an address of '2'. If we read tape address 2 we get back the letter 'c'. So the address is locating the 'c'. Now suppose we write at address 2. Say we write 'γ'. Now our sequence is:

+ + + a, b , γ, ε, ε, ε … + + +

Now we write 'Г', resulting in the sequence:

+ + + a, b , Г, ε, ε, ε … + + +

It would appear that the answer to our question is that address 2 is locating different things at different times. First it was, c, then γ, then Г. Yet the address did not change. It feels a little unsatisfactory to suggest that our concept of location depends on the value addressed. Also, notice, that when we made the Natural Number Turing Machine, that the values on the tape that was placed into correspondence with the Natural Numbers were never mentioned. Yet, we can't seem to answer the question of 'what is being addressed' without giving a value.

+ +

Addresses speak to the structure of the tape rather than the values held on the tape. So as to facilitate this interpretation, we note that a sequence consists of a sequence of cells holding elements, rather than being simply a sequence of elements. Given the concept of a cell we can say that an address always locates the same cell, though the contents of that cell can change.

+ +

This operates similarly to a small extension to the already existing concept of a variable in mathematics. In mathematics we allow that a variable can take on different values, though its name never changes. Now we are going to say that a cell can take on different values, though its address never changes. Furthermore, as the cell is part of the sequence, we are going to say the cell itself has a left neighbor or right neighbor, excluding the value in the cell.

+ +

Address of an area

+ +

The address of a cell is the number of steps required to reach the cell when starting from the leftmost cell on the tape. The leftmost cell has an address of zero. It might seem intuitive to set the address of an area on the tape to be that of the first cell in the area. If we require that an area have at least one cell to exist, this approach works even for machines with a cell delete command.

+ +

Suppose that we are deleting the cells in an area. The delete command affects the cell to the right of the cell the head is on. Hence to delete all the cells of an area, the head is placed on the left neighbor cell to the area. Say that we delete an area of three cells. We will call delete three times. It seems unsatisfactory to say the area no longer exists after the three deletes because the head locating the area never moved. I.e. we still have a location marker for the area, so we could, for example, call append and put a cell back into the area. For the area to truly not exist, it would not have a location.

+ +

Thus it seems more satisfactory to locate an area by its left neighbor cell, than to locate it by its leftmost cell.

+ +

The inverse case also suggests that the cell to the left of an area defines its address. I.e. if we call append to grow an area, it grows to the right of the cell the head is on. According to this definition of area location, the rightmost cell locates a currently zero length right tail of the tape that will potentially be grown.

+ +

In a sense what we are doing while exploring the meaning of area, existence, and zero length with these delete and append examples is performing a discrete limit in analogy to a limiting operation in calculous. To support having such a limit operation, the location of an area is that of the left neighbor of the leftmost cell in the area.

+ +

Not all is satisfactory. When using the left neighbor of an area as the location for an area, we cannot locate an area that starts on the leftmost cell of the tape. If we make this a special case, then we have failed to make a first order definition for area, because the special case information will have to be stored in a higher level structure that describes attributes of the tape.

+ +

Nor can this use the left cell approach work in the case of multiple areas.

+ +

Suppose we have two adjacent areas.

+ +
+ Tape with two areas +
Figure 2 Tape with two areas
+
+ +

Here we show a first area, say a0, that includes cells 7, 8 and 9. And a second area, say a1, that includes cells 10, 11, and 12. Thus, by the convention of using the address of the cell to the left of an area as the area’s address, a0 has an address of 6, while area a1 has an address of 9. Because the areas are adjacent, the address of area a1 is the same as the address of the rightmost cell in area a0.

+ +

We know that area a0 is located to the left of area a1 because a0's address is less than a1's. I.e. 6 < 9.

+ +

Suppose we delete cell 10. Though cell 10 is gone, our addresses remain consecutive, so what was cell 11, is now called cell 10, etc. and the diagram appears much as before, though area a1 is now only 2 in length:

+ +
+ Step by step area two becomes shorter +
Figure 3 Step by step area two becomes shorter
+
+ +

Now we delete the cell at address 10 two more times, and all the area a1 is gone. During the deletion, and just after, the head will be on the rightmost cell of area a0, i.e. on cell 9. We can now say we have an area of zero length located at cell 9.

+ +
+ Second area goes to zero length +
Figure 4 Second area goes to zero length
+
+ +

Now suppose after deleting the area a1, as just described, we continue on to delete area a0. Each time we delete the leftmost cell of a1 the rest of area a1 moves left by one. Hence, after the first deletion the address for empty area a1 becomes 8. Area a0 is still located to the left of a1, because 6 < 8:

+ +
+ Limit towards zero length being applied to the first area +
Figure 5 Limit towards zero length being applied to the first area
+
+ +

Finally when all cells in area a0 have been deleted, a1 has collapsed into a0. Both have the address of 6, so the order between them can no longer be derived from looking at the base addresses. Should we attempt to reverse the steps above, and only be given the machine at its final state we would have to begin by guessing what the order was between the two areas, a0 and a1.

+ +

So again, there is either missing information, or some information is not stored on the tape we are discussing.

+ +

As yet another problem case that is either not possible or requires external information, if an area includes the leftmost cell of the tape, then its location cannot be described with an address.

+ +

Hence this approach of using a discrete analogy to limits has led to some unsatisfactory end cases. We will visit this subject of areas on tape in the section, Area as a mapped tape and present a higher order approach for defining area location that avoids such end cases.

+ +
+ + +
+ + Some properties of Turing Machines + +

For a given Turing Machine, the input is the sole determiner of the output. I.e. each time the same input is given, we get the same output. The input and output are mathematical objects, hence Turing Machines are functions. However, it is common in computer science to speak of Turing Machines as 'solving problems' rather than saying they are functions. This is because we often think of the inputs and outputs of Turing Machines as being something other than mathematical objects. For example, when a Turing Machine sorts sequences found on its input, we might say that it solves a sorting problem.

+ +

Turing Machines will differ due to differing alphabets, state controller graphs, associated commands, start, and halt states. The choice of empty-symbol is inconsequential as long as it is distinct from the alphabet. As we will see in the later discussion on variations, the choice of alphabet is not very important. For two alphabets of the same cardinality we can setup a one to one mapping, and for those of differing cardinalities we can use sequences of alphabet symbols that map to alphabet symbols. For example, given an alphabet of ‘T’ and ‘F’, and a second alphabet of ’t’, ‘f’, ‘x’, ‘z’ we may make the following map:

+ + + f + | FF + + t + | FT + + x + | TF + + z + | FF + + +

Then given this mapping, we may use two cells for each one cell for any {‘f’, ‘t’, ‘x’, ‘z’} alphabet machine, and then use the only the {‘T’, ‘F’} alphabet.

+ +

There are a countably infinite number of permutations for alphabets, state controller graphs, associated commands, start and halt states, hence there are a countably infinite number of Turing Machines that fit our definition. However, there are an uncountably infinite number of mathematical functions. Consequently, we must expect that some functions cannot be computed with Turing Machines.

+ +

There might be multiple Turing Machines that perform the same function. A set of such machines forms a functional equivalence class. Within a functional class there will be a class of members related in that they all use the smallest number of steps when considered against the limit of input length. We discuss this further in the section on complexity.

+ +

Of special importance to computation theory is the existence among all these infinite Turing Machines of a class of machines that read their state controller definition from the tape as an input. This is the Universal Turing Machine class.

+ +
+ + Performance Analysis + +

An interesting aspect of the Turing Machine procedure is that it introduces the concept of stepping the machine. With the addition of some simple constraints it becomes possible to map the parts of the Turing Machine abstraction to the parts of some real machines. These constraints may take the form of such things as bounds on the length of the inputs, or the addition of out-of-resource errors. Because such constraints do not affect the 'normal' workings of the machine, the derived relationship between a Turing Machine step, and that of a unit of real time might not be that complicated. Indeed, except for some enumerable cases this relationship might even be so simple as to assign to a step an approximately constant amount of time.

+ +

Because of the existence of a relationship between steps and time, particularly when it is a simple one, it is very interesting for us to know how many steps a Turing Machine will take.

+ +

There are many ways to measure the complexity of a Turing Machine. Among these is something called the time complexity, which is a function that relates the length of the input to the number of steps required to reach the halt state.

+ +

To derive time complexity we typically start with a step count formula which maps the length of Turing Machine input to the worst case largest number of steps. We then consider the behavior of this formula as input length goes towards infinity. To get this, we take the highest order term from the step count formula. Conventional results are constant time, polynomial time, or exponential time.

+ +

We can derive the 'worst case length of the area written or read by the machine during computation' function in an analogous manner as for the step count function. This function is known as the space complexity. We may also consider the limiting behavior of this function to derive an order of space complexity.

+ +

The order of time or space complexity will remain the same against certain variations of our Turing Machine definition. For example, if we double all the states by adding a second state that we always visit, where this second state does nothing, the number of steps would double but the functionality would not change. Order of complexity also would not change. A fixed time machine before doubling up on the states would still be a fixed time machine afterward. It is simply that the number of steps would be twice as large, but still a fixed number relative to the size of the input. A polynomial time machine would still be polynomial time, simply with double size constants. We say that changes which do not change order of complexity, nor existence proofs, are inconsequential.

+ +

Suppose we have a complete Turing Machine functionality class. We say that it is complete because all possible machines for implementing the function are in this class. Some machines in this class will have a different order of time complexity than others. Now we consider the set of minimum order of time complexity machines from this class. As the larger set was complete, the set built against this constraint will also be complete relative to the constraint. We then say that this minimum order of time complexity is a property of the problem being solved, rather than being a property of a particular machine.

+ +
+ + Conventional Turing Machine variations + +

In the first section of this chapter we gave a rather conventional definition for a Turing Machine. In the prior section, Complexity, we noted that we can analyze Turing Machines to find their time and space complexities. In this section we will discuss some variations that a person finds in the literature.

+ +

A variation on the conventional Turing Machine definition is allowed when it can be proven that the variation never causes existence, order of time complexity, nor order of space complexity results to change, and in this respect is inconsequential. Earlier we gave the example of doubling up the states as being such a variation, though that is an excluded variation typically.

+ +

Open in both directions tapes

+ +

Some Turing Machine descriptions describe a tape with no end in either the left or right directions, i.e. a tape that is open in both directions.

+ +

This feature adds no richness of expression, because we can get the same behavior from a Turing Machine with a single ended tape. To do this we partition the single ended tape into odd addressed cells and even addressed cells. The odd cells are said to be the right side of the tape, and the even ones the left side. We then rewrite any tape controller based on a bidirectional tape to instead use the 'odd' and 'even' channels instead of the left and right sides of the tape.

+ +

This same approach form can be used to show that multiple tapes, or even multi-dimensional tapes, add no expressive power. The good news is that such variations can be used whenever convenient, and we will get the same results.

+ +

Going in the other direction, the open in both directions tape is not a simplification. There is still a start cell, being the cell that the head is initially placed on. And as noted above, the topology around this start cell is no different, it is simply a question of the adjectives we use for describing it.

+ +

Alphabet replacement

+ +

Without loss of generality, we may replace the alphabet with a single symbol, say 's' (short for successor). This is because symbols in any alphabet can be placed into correspondence with a sequences of 's' symbols. For example, the symbols of the alphabet of {w, x, y, z} can be placed into one to one correspondence with the sequences in the manner of {<w, s>, <x, ss>, <y, sss>, <z, ssss>}. We will need to put the empty-symbol between any such sequences on the tape, so that two sequences can be distinguished from one longer sequence.

+ +

Alternatively we can adopt a two symbol alphabet instead of a single symbol, where the second alphabet symbol is an end of sequence marker.

+ +

In contemporary computing we use an alphabet of two symbols, {0, 1}, and fixed length sequences. No end marker is needed when the sequences to be placed into correspondence are of fixed length. So for example, the symbols in the alphabet {dog, cat, mouse, fish} may have the correspondence of {<dog, 00>, <cat, 01>, <mouse, 10>, <fish 11>}. Conventional fixed sequence lengths are 8, 16, 32, and 64. So for example, when the sequence length is 8, any alphabet of 256 symbols or less may be placed into correspondence. A conventional correspondence table is that of the ASCII code.

+ +

The fixed length to be used can depend on computational context. (In contrast, UTF8 does not use fixed length sequences, so there must exist at least one end of sequence marker.)

+ +

Another alternative to end of sequence markers for variable length sequences is to externally account for sequences lengths. We call such an accounting system a type system.

+ +

Leaving out the empty-symbol

+ +

When we use a fixed sequence of {1, 0} to stand for symbols, it is expensive to reserve a sequence for the empty-symbol. This expense is due both to losing the use of a symbol in the alphabet, and in the complexity of control circuitry when keeping track of it.

+ +

The empty-symbol functions as a property of the machine rather than simply another alphabet member, because the tape initially has an infinite tail of empty-symbols. A computational Turing Machine is limited to taking a finite number of steps. Thus it cannot compute a tape initialized with an empty-symbol (or any other value).

+ +

However we can add a constraint on all Turing Machine controllers that requires of controllers that they never write the empty-symbol, and always write an alphabet symbol to a cell before reading it. Then, because a cell is never read before being written, it does not matter what we write into it for initialization. We may even use an alphabet symbol. Consequently this constraint allows us to eliminate the empty-symbol. This gives us the following Turing Machine variation:

+ + + 1. fixed finite alphabet + 2. fixed write before read constraint + 3. variable single ended tape + 4. variable read/write head + 5. variable read value buffer + 6. fixed controlling state machine + 7. fixed left from leftmost error + 8. fixed start state + 9. fixed halt state + 10. variable current state + 11. fixed procedure for using these. + + +

To validate that this is an inconsequential Turing Machine variation, rather than a description of new abstraction that is not a Turing Machine, we must show two things: Firstly, that any of the now disallowed controllers never compute something that cannot be computed in the presence of the constraint. And secondly, that there are same complexity class alternatives for any disallowed controller.

+ +

No need to step into the inactive area

+ +

1. When attempting to step into the inactive area, instead keep a counter for the number of steps the machine would take. Only allow reads or writes or head movement when the counter is no longer needed due to the head having moved back into the active area.

+ +

2. Write an alphabet character and change the inactive area traversed into an active area.

+ +

The TTCA Turing Machine variation

+ +

The active area on the tape can grow at most by one unit for each machine step. This largest growth occurs when the Turing Machine steps right and writes an alphabet character in every visited state. This means that for computational machines that start with a tape that has a finite input (active area), the output (active area) will be finite. This also means that space complexity can never be larger than time complexity.

+ +

A fixed value is one that is provided with a Turing Machine definition, and does not change while the machine runs. Suppose we chose a fixed length Turing Machine tape. The tape would then have a rightmost cell. That cell would have no right neighbor, but would have a left neighbor. We would also add another error, that of right from rightmost. This error would be invoked when the controller attempted to step right from the rightmost cell.

+ +

Consider a machine that does not step out of the active area, has constant space complexity, and where this space complexity is less than the fixed length for the finite tape; such a machine would never trip the right from rightmost error, and thus there would be no difference between a finite tape and an infinite one.

+ +

Now suppose that we bound the length of the input, and that the maximum space required for such inputs or shorter ones is less than or equal to the length of the tape. Then again, the right from rightmost error would never be taken, and thus the tape would be indistinguishable from an infinite one. (Today we typically pad programs with lots of memory and long address words in hopes this will be the case.) An analogous argument can be made if we bound the number of steps that may be taken.

+ +

Now consider the case where we do not fix the length of the input, nor the number of steps allowed, and that space complexity is such that space usage grows with growing input length, at least for very long inputs. For such machines we can always find an input of sufficient length to trip the right from rightmost error.

+ +

As another approach to finite computing we can run computations twice. For a given input we first run the Turing Machine variation that does not step out of active area but still has an infinite tape. We watch this machine closely while it is running and find the bound on the active area. Now we can make a second machine that has a fixed length tape at least as long as our active area measurement but is otherwise the same. Now with this second machine we can run the same input and there will be no right of rightmost error, and thus there will be no difference between having the finite tape or an infinite one.

+ +

Unlike for the constant space complexity proposal, and the bounded input length proposal, which only work for small subsets of potential inputs, this 'run twice' proposal derives a finite machine that works for any given input which a Turing Machine works for. Though, unfortunately, in all cases the second run will be moot, as we could have simply taken the output from the first run.

+ +

In a variation on the run it twice approach, instead of running the first machine, we might instead analyze it and should we be able to surmise a maximum tape length, we could use that.

+ +

In yet another approach we can extend the finite tape as needed. We place a control layer over the finite tape. When a step right command from the Turing controller invokes the right from rightmost error, the lower layer allocates memory, lengthens the tape, and then performs the requested step right. As long as this occurs in fixed time, (or of sufficient lesser order time than the dominate order of the time complexity), and as long as there is indeed more memory to allocate - this Turing Machine variation will yield the same order of computational complexity as one with an an infinite tape.

+ +

I propose the following Turing Machine variation:

+ + + fixed finite alphabet + write before read constraint + variable and extendable finite tape + variable read/write head + variable read value buffer + fixed controlling state machine + fixed left from leftmost error + fixed right from rightmost error + fixed start state + fixed halt state + variable current state + fixed procedure for using these + + +

In our original Turing Machine model, the controlling state machine commands were limited to, do-nothing, step-left, step-right, write, with reading as an implied command. To this list we add append. The append command may only be called when the head is on the rightmost tape cell. This is not limiting because the command may be called from a state that is at the end of an arc triggered by the right from rightmost error. When we have no empty-symbol, append accepts an alphabet symbol and performs a write into the new cell. This is not limiting because if need be, a person can always perform an extraneous write of an alphabet symbol.

+ +

With this extendable tape model all Turing Machine components remain finite during computation, though some are arbitrarily large. This variation is more suited for creating a mapping between a Turing Machine and a real program running on a real machine. Specifically, a computation requiring N cells maps exactly to a physical machine possessing at least N cells. The theoretical model and the physical implementation remain perfectly isomorphic provided the physical environment does not exhaust its memory bounds. Because a computational TTCA machine demands strictly finite tape extensions, a physical machine that completes the execution maintains exact structural correspondence. This isomorphism holds continuously as long as memory remains available, even accommodating dynamic hardware expansion such as memory hot-swapping. The theoretical correspondence fails solely upon a hard physical limit being reached during execution.

+ +

More about commands

+ +

The Turing Machine state controller has a command symbol tied to each state. The Turing Machine procedure then has us take action based on this symbol. This is our current command set:

+ + + step-right, causes the head to move to the right neighbor cell. + step-left, causes the head to move to the left neighbor cell. + read, returns the symbol under the head. The returned symbol is then used to chose the transition arc. + write(x), causes the symbol x to be written to the cell that the head is currently on. The symbol x is any symbol from the alphabet. + append(x) may only be called when on the rightmost cell. Extends the tape by one cell, and writes the symbol x into that cell, where x is any symbol from the alphabet. + + +

We are going to relieve the constraint that append can only occur from rightmost. Our new append is functionally identical to adding a cell to the rightmost extremity, and then shifting all the symbols over by one cell starting at the new cell and ending when the new rightmost has been written - and then doing the requested write of x on the right neighbor cell.

+ +

We will also include the inverse function for append. delete(append(x)) reads x while deleting the cell that x was in. The current Turing Machine model can emulate this function by shifting all the symbols in cells the right of the head left by one, and then simply not using the rightmost cell.

+ +

We are also going to support multiplexed state controllers. Our multiplexed Turing Machine will have multiple heads. One for each separate thread of execution through the state controller. As explained in the following chapters, supporting multiplexing makes our machine more complex, especially in the presence of the delete command. However, we defer that discussion to the relevant chapters.

+ +

In cases where successive states are visited in a fixed order it is convenient to combine the commands. We have developed the concept of a command statement to support this:

+ + + statement::[direction]command+[modifier][&contract]*[arg]* + direction::- | ε + command::r | w | s | a | d | m | e | ☥ + modifier::◧ ◨ n + command + r read cell under the head + w write cell under the head + s step + a allocate/add/append a new cell + d deallocate/drop/delete cell + m move, no allocation or deallocation of cells, requires fill + e entangled copy + ☥ entangled copy on a new thread + modifier + ◧ operate on leftmost + ◨ operate on rightmost + n repeats n times, n provided through an argument + contracts + h◧ head is at leftmost + h◨ head is at rightmost + examples + -s ; step left + a◧ ; make a new leftmost cell + a◨ ; append to rightmost + sn ; step n times + to derive a longer command, combine them: + as ; append then step + -a-s ; append to the left, step to the left + + +

The left direction is specified with a minus sign, otherwise the direction is taken as right going. So the letter s is the step-right command, and -s is the step-left command. The command s3 steps right three times.

+ +

The command a appends and writes a new cell to the right of the head. We use two special characters from the UTF character set to signify the rightmost and leftmost of the tape. This one looks like a little tape with its left cell inked in, ◧, so we use it to stand for leftmost. We use this one, ◨, to mean rightmost. Hence a◨ makes a new rightmost cell, and a◧ makes a new leftmost cell.

+ +

In some cases it is possible to implement higher performance implementations for commands when the programmer tells us some additional information. For example a◨&h◨ has identical functionality as a◨, while the programmer also guarantees that we are on the rightmost cell. This saves the function from having to scan to the end of the tape.

+ +

We can concatenate the command letters into a string to summarize what would happen sequentially in adjacent state transitions. If these compound commands need arguments, then they are pulled from the argument list in order as they are needed. For example, as means to append, with the parameter for the append taken from the argument list, and then to step.

+ +

We support multiplexing with the command e, which is short for entangled. This operator returns what appears to be a second independent machine, but this apparently independent second machine actually shares the same tape with the first machine. It is functionally identical to giving one machine two heads, and thus the ability to have state sets.

+ +

The command esr is a compound command referring to sequentially applying three other commands. The e says to make an entangled copy of the head. The s says to step this copy, and the r says to do the read. The analogous esw does a write as the last step. This sort of combination of letters to make more complex commands was inspired by Lisp's car and cdr compositions. Though this is functionally what the command does, its actual implementation might be completely different.

+ +

The combination of multiplexing and cell deletion leads to a hazard where one thread can delete a cell the head is on in another thread. We add a collision error continuation to our multiplexed Turing Machine interface because of this situation.

+ +

Chapter discussion

+ +

The modifications to the Turing Machine leading to our TTCA machine were inconsequential, in that for order of complexity and existence proofs we may swap one machine for the other and the results will be the same.

+ +

The original Turing Machine had an infinite tape. In contrast the TTCA machine has a surprising property: for computational problems all of its components remain finite. This follows from the fact that during computation a machine makes a finite number of steps, so the tape can only be expanded to be a finite size.

+ + Consequentiality across the design abstraction stack + + +

Choice of realization

+ +

+ Let us take the example of adding two Arabic representation numbers. Logically this is considered to be a logarithmic time problem. We break the operands into fixed length pieces, and adding them in pairs results in a carry per block. By recursively pairing the blocks and applying the carries, we generate wider carries. Thus we can show that in terms of the logic gates that must be traversed, the sum is a log time operation. +

+ +

+ Physics comes to a different conclusion. In the worst case, a carry into the least significant bit can affect the sum bit some physical distance away. As the operands get longer, this distance grows in proportion. So given the propagation of information at a fixed speed, the bounding evaluation time against growing operand width is linear time. Even if it is log time in gate count, at some point the interconnect delay will dominate. +

+ +

+ The logical analysis of the adder given above allowed for unbounded resources, because as the adder operand increases in size, the number of block adders increases without bounds. In any realization there will be a limit on the number of blocks that can be added in parallel. These groups are then processed one by one, and the carry is propagated between them. Consequently, as the operands grow in length without bounds, the adder evaluation time becomes proportional to the number of groups processed. Processing groups in series is a linear time algorithm. +

+ +

+ It is notable that the time-multiplexed use of computer resources produces the same linear time result as the physics of information propagation analysis for the adder. +

+ +

+ A Turing Machine program faces a situation analogous to physical constraints. Given the operands are found on the tape, and the carry-in can affect the msb of the sum, the head will have to move ever more cells rightward to convey that lsb information up to the msb. Based solely on the propagation time of that information, addition is found to be a linear time algorithm. This propagation remains computation class limiting even if the Turing Machine is given an unbounded number of independent heads. +

+ +

+ There appears to be alignment among physical limitations, resource limited computing, and steps spent by Turing Machines while they carry information across a linear tape. This alignment indicates that a reasonable realization will be computation theoretic inconsequential. +

+ +

+ At this point we have arrived at questions of the physics of computation. The above analysis made use of classical physics. Perhaps realizations based directly on principles from Quantum physics models will be computation theoretic consequential. +

+ + +

Choice of implementation

+ +

+ From Babbage's Analytical Engine of 1842 up to the transition to mechanical relays and vacuum tubes in the 1940s, calculating machines were implemented with gears. The basic principle is apparent to anyone who has seen a mechanical odometer. Consider adding numbers for example: given two odometers, step one back at the same time as stepping a second one forward; when the first one reaches zero, the second will hold the sum. This process can be optimized, but the general idea remains the same. For such machines, a step is a rotation of the main shaft. +

+ +

+ The Harvard Mark I machine had a main axle speed that maxed out at 3000 RPMs, say 2700 RPMs to keep our math simple. Then this is 2700 steps per minute. The ENIAC was a similar implementation, but one that called out the use of circular shift registers of vacuum tubes instead of mechanical gears. Because there were 10 tubes in a ring register, it took 10 clock ticks to complete one 'rotation'. The clock rate maxed out at 450 kilohertz. That would be one rotation every 1/45,000 of a second, or 2.7 million RPMs, an improvement of three orders of magnitude! +

+ +

+ Yet, the same program when run on the Mark I took the same number of steps as on the ENIAC. But more importantly, a linear time algorithm on the Mark I was still a linear time algorithm on the ENIAC, etc. Thus, these implementation differences were computation theoretic inconsequential. +

+ +

+ It feels unsatisfactory to leave out the tremendous difference in clock rates. So let us address this feeling by naming an ENIAC main shaft 'rotation' as a standard 'step'. If we do this, then a Mark I shaft rotation would be 1000 ENIAC steps. Yet, this would merely affect the linear constant in the step count formulas. The same programs can be run, with the same inputs, and asymptotic behavior is the same for both machines, because computation classes do not include the constants on the step count equation. Constant time remains constant; linear, polynomial, and exponential time classes are the same as before. Programs that decide questions would get the same answers when they completed. +

+ +

+ Because we made an ENIAC shift register turn completion a 'standard step', we have a relative measure, so there is something we can do to create a computation theoretic consequential difference. Suppose we have two ENIAC machines, and we send one speeding away from Earth at an exponentially increasing rate, i.e. increasing red shift, and we observe it from Earth. We will observe that the clock on the traveling ENIAC is growing ever slower, and that a linear time program running on it will be observed to have exponential time behavior. Unfortunately, relativity does not smile upon us, as the people on the spaceship would not see the inverse, a speeding computation on Earth, but rather they would also observe a slowing one. +

+ +

+ So then, instead we send a spaceship towards Earth, with increasing blue shift, and we would observe that spaceship's ENIAC getting faster and faster. This is still not a computation theoretic speedup, because it is not asymptotic. In finite time, said spaceship would run into Earth, or pass it by and then be red shifting. +

+ +

+ A designer could purposely slow the clock on a second ENIAC so as to emulate red shift. For this to be more than mere theater there would have to be physical reason to run a slower clock than necessary, for example perhaps for conserving an ever dwindling battery. But slowing computation down, or even stopping it, is typically not useful. However, going the other direction, an ever faster clock does not work, as there is a finite maximum physical clock speed. +

+ +

+ We get an increasing blue shift situation with Moore's law. If every generation transistors become exponentially smaller, and thus faster, and we consider step times in years, hopping from new realization to new realization, then indeed linear time algorithms on a single realization would be log time algorithms on the generational computer. But chances are this is not an asymptotic, i.e. limit to infinity, phenomenon either. +

+ +

Choice of organization

+ +

+ Superscalar and VLIW computers execute multiple instructions in parallel. Real data dependencies put limitations on how many instructions are available to be executed in parallel, but even discounting this, if a program were executed N instructions at a time, its time to execute would divide by N. This merely affects the linear component of the equation mapping step count to input length, and thus does not change the computation class. Superscalar and VLIW architectures do not affect decisions; indeed they are transparent to programs, so decider problem results cannot change. Hence these techniques are not computation theoretic consequential. +

+ +

+ In general, by definition, organizations do not change a program's view of the machine, as that is part of the architecture. So organizations will not affect decider results. Also, the memory operations will be the same, as that is viewable state, so space complexity does not change unless time complexity changes. +

+ +

+ The realization sets fixed resources, so any attempt at parallelization will be bounded, as in the superscalar and VLIW discussion above. Thus at best it can divide the execution time by N. +

+ +

+ Some organizations can arrange computation in a manner that the base clock can run faster than for other organizations. However, clocks run at a fixed maximum speed. On modern systems they can slow down to reduce heat dissipation or battery consumption, but that does not make programs faster. So if one organization has a faster clock than another, the ratio is merely a linear term contributor. Apart from stopping, there is nothing a clock can do to participate in the decision making of the program. +

+ +

+ Caching of values sent to the system memory again does not participate in the decision making of a program. We are at best looking at improvements in the linear term. +

+ +

+ Branch prediction saves the time required to do a full fetch, but fundamentally it does not change the data flow graph of the program. The same decisions are made. +

+ +

+ Suppose that an organization keeps the operands for a function in a content-addressable memory. When the operands are recognized, it then immediately returns the looked-up value. This approach, called memoization, bypasses the internal looping of the function. Hence, this does participate in the decision making of a program, and could potentially change the computation theoretic complexity of programs with certain properties where the same operands occur in patterns and lead to an expensive computation. Memoization is typically designed into computer languages, rather than being built into the organization of a computer. Chances are, at the computer organization level or lower, it is more efficient to simply execute the presented instructions. +

+ +

Choice of architecture

+ +

+ Common decisions made at the architecture level are those for supporting RISC or CISC, the bit layout and handling of operands, the size of the internal register file, how DMA is to be handled, whether to use memory-mapped I/O or have explicit instructions for it, how interrupts are to be implemented and the number of entries in the interrupt table, what special registers are present and what features are available through them, how virtual memory and its user and process IDs are to be implemented with the possible use of a translation lookaside buffer, what onboard execution units will have direct instructions, the built-in data types, questions of unaligned accesses, bus standards to be supported, if sleep modes are to be present, how the machine will get booted, the security rings that will be supported, details of the hardware virtualization layer, special support for the OS, how the system stack will be handled, potential partitioning of address space, support for large buffers, and memory sharing features: none of these are computation theoretic consequential. +

+ +

+ As architecture enters the gray area with organization, cache architecture, bus layouts, bus buffers, direct inclusion of write buffers, perhaps a stack cache, prefetch buffers and split-transaction buses: none of these are computation theoretic consequential either. +

+ +

+ Said features certainly affect performance, but none participate in the decisions the program makes, change the number of execution steps by more than a linear ratio, or alter the memory complexity of the program. +

+ + + + +
+ + TTCA Turing Machine in Lisp + +

Because our TTCA Turing Machine has finite sized components, we may create a software model for the TTCA Turing Machine without having to make assumptions of the sort that ‘very large approximates the infinite’. Rather we can show a one-to-one mapping of code and data in the software model and the TTCA variation of the Turing Machine. Consequently, the software model and theoretic model are isomorphic.

+ +

It follows that we can use our TTCA Turing Machine software to make theoretical statements about computation in the form of programs. By following this path we will learn some interesting things in this chapter about analysis, the meaning of emptiness, data type, the properties of non-destructive vs destructive programming styles, and multi-threaded programming among other things.

+ +

The Turing Machine, and our variation of it, may be partitioned into two parts. One part of the part consists of the tape head and the tape. We call this the Tape Transport Unit, as that is the name used for the mechanism that does this work on real tape storage units. The other part of the part is the Controller.

+ +

The Tape Transport Unit accepts commands for reading, writing, and moving the head. (In real Tape Transport Units the head is in a fixed position and we move the tape, but the relative affect is the same.) Our modified model adds commands for extending the tape. During normal operation these commands only come from the controller.

+ +

We have two types of controllers. One type of controller is a state machine. Its design is an integral part of the Turing Machine. To step the Turing Machine means to step this state machine to its next state. The state machine definition exists before the Turing Machine takes its first step, and its definition remains intact for as long as said Turing Machine exists.

+ +

When we speak of a Turing Machine without adding further words to the term as qualifiers, we mean that it uses this type of controller. For clarity we can call this a Directly Controlled Turing Machine.

+ +

The second type of controller is the Universal Controller, and a Turing Machine that uses this type of controller is called a Universal Turing Machine. The Universal Controller reads the definition of a state machine controller off of the tape. Hence the Universal Turing Machine may emulate any Directly Controlled Turing Machine. We can also call this an Indirectly Controlled Turing Machine. Here the qualifier ‘Indirectly’ is intended in the sense it is used in assembly languages, meaning the data is not present in the controller, but rather it must be fetched from memory.

+ +

With our Tape Machine library, your program is the controller, and the library implements the Tape Transport Unit. (In the future I will rename this library to ‘TTU’ from the current ‘TM’. Also the use of the term ‘function’ will be changed to ‘routine’.)

+ +

Your program that uses the TTU library is in a sense direct control, because the program is already defined before the first step of the machine, and with the possible exception of self-modifying code, it does not change until the program exits, and thus the process no longer exists. On the other hand, your program is loaded from memory by the processor, thus demonstrating that the processor is an indirect, i.e. universal, controller. Either interpretation works depending on how broad of a view we want to take.

+ +

Installing the library

+ +

TM is presented as an iteration library on the de facto package manager for Lisp quicklisp. Alternatively, a person may clone the repository www.github.com/Thomas-Walker-Lynch/tm and then checkout the latest release tag, which as of this writing is v0.7-alpha. After installing the code cd into the tm directory and run your lisp interpreter. Inside your lisp interpreter type the commands (load “load”) and (test-all). test-all should return with a message that all of the tests passed.

+ +

It is possible that the threading tests, 'ts1-' might fail if your machine is heavily loaded or very slow, as they have timing built into them, but this is unlikely. Then type either (use-package :tm) or (in-package :tm) depending on what your objectives are.

+ +

The examples in this chapter either come from the tm/test directories, or from the tm/docs/examples directory. At the time they were placed in the book, they executed correctly, and I have endeavored to keep the examples up to date.

+ +

This is what it looks like when I follow install using the git clone method:

+ + + > git clone http://www.github.com/Thomas-Walker-Lynch/tm + Cloning into 'tm'... + remote:Counting objects: 3052, done. + remote:Total 3052(delta 0),reused 0(delta 0),pack-reused 3052 + Receiving objects: 100% (3052/3052),2.41 MiB|1.52 MiB/s,done. + Resolving deltas: 100% (2366/2366),done. + > cd tm + > git tag + v0.1-alpha + v0.7-alpha + > git checkout v0.7-alpha + Note: checking out 'v0.7-alpha'. + You are in 'detached HEAD' state ... + > sbcl + This is SBCL 1.3.14.debian ... + * (load "load") + ; compiling file "/home/tm/package-def/conditions.lisp" + ; compiling (IN-PACKAGE #:TM) ... about 10 pages of these + hooking test: TEST-TS1-5 + T + * (test-all) + + TEST-UNWRAP-0 + ... about a page of these tests + + TEST-TS1-5 + all 78 passed + T + * (use-package :tm) + T + * (≠ 1 0) + T + * + + +

Notice I used git tag to see the releases. At this time, v0.7-alpha is the latest, so I checked that out. If you want the unstable latest code rather than the stable latest release, leave out the git checkout command.

+ +

The TM Library makes use of Unicode. There is no getting around it. This is discussed further in the next section. In addition TM defines synonyms for commands such as 'not equal', which is the one command shown at the end of the transcript given above.

+ +

Unicode usage

+ +

For your convenience there is a file "emacs-keys" in the docs directory of the distribution. It sets the C-x g name SPC command to enter one of the Unicode characters that are used in the library. Here 'name' is a nickname.

+ +

So to type the character capital delta after emacs-keys has been loaded, type C-x g D SPC. Actually Δ occurs twice in Unicode, once as capital delta, and once as a symbol for 'increment' in mathematics. We consider the increment version to only be there for typography purposes. We only use capital delta, even when it is for an increment variable.

+ +

I've limited the use of Unicode mostly to things that 'probably would have been this way had Unicode been around before'. This includes conventional notation and a couple of symbol extensions that were needed to facilitate the TM access language.

+ +

In the file src-0/fundamental.lisp find synonym bindings for the usual operators and common symbols such as ∧, ∨, ≥, ≤, λ, ∅, etc.

+ +

Specific to the library we use the character '◧' as shorthand for 'leftmost'. This is because it looks like a little tape with the inked over cell being the leftmost cell. In the same manner the character '◨' is shorthand for rightmost.

+ +

We use '➜' in continuation function names, and '⟳' as a loop operator.

+ +

The ◧ and ◨ symbols are used in compound command names and for access language statements to indicate operation on rightmost or leftmost rather than the cell the head is on, or, to specify contracts with the programmer of the sort: "this function is only called when the cell is on rightmost."

+ +

Since I had symbols for leftmost and rightmost, I started using them generally to mean leftmost or rightmost wherever it was convenient. For example, to shorten up the names of continuations so that parameter lists would fit on a line.

+ +

Synonyms

+ + + (defmacro defsynonym (old-name new-name) + "Define OLD-NAME to be equivalent to NEW-NAME." + `(defmacro ,new-name (&rest args) `(,',old-name ,@args)) + ) + (defconstant ∅ nil) + (defsynonym /= ≠) + (defsynonym <= ≤) + (defsynonym >= ≥) + (defsynonym not ¬) + (defsynonym and ∧) + (defsynonym or ∨) + (defsynonym string/= string≠) + (defsynonym string<= string≤) + (defsynonym string>= string≥) + (defsynonym lambda λ) + + +

Some reader macros

+ +

q – a non literal quote

+ +

In Lisp a quoted list is taken as being literal. However the result of modifying a literal is undefined, and often leads to bad results. Hence we provide the macro q which returns a quoted list which is not a literal.

+ + + * (q a b c) + (A B C) + + +

{…} - unevaluated list

+ +

When a form enclosed in parentheses, ( ... ), is evaluated the head is taken as the name of a function, looked up and called. The list members are also evaluated, and then passed as arguments to said function. If we don't want the head treated specially, but rather want to define a list, we can use a front item of #'list, which is the function to create a list.

+ + + * (list 1 2 (+ 1 2)) + (1 2 3) + + +

We have defined a macro called L that like #'list, creates a list, but which also has some extra functionality.

+ + + * (L 1 2 (+ 1 2)) + (1 2 3) + + +

We also provide a reader macro for L as braces.

+ + + * {1 2 (+ 1 2)} + (1 2 3) + + +

If the apparent function open, #'o, appears inside of a call to L, then the arguments of the #'o function are included directly in the resulting list:

+ + + * (defvar a {1 2 3}) + A + * (defvar b {4 5 6}) + B + * {a (o b)} + ((1 2 3) 4 5 6) + + +

Quoted non-literals can also occur within such an L list:

+ + + * {a (o b) (q a b)} + ((1 2 3) 4 5 6 (A B)) + * {a (o b) (o (q a b))} + ((1 2 3) 4 5 6 A B) + + +

L acts identically to a quasiquote turned inside out. Whereas the default in quasiquote is to quote items, and a comma operator turns that off, the default in L is to evaluate items, and a q operator turns that off. Quasiquote has an @ marker to open up lists, while L has an o operator to open up lists. Inside of a quasiquote we could get in trouble if the name of a variable starts with an @ character; if such a variable appears after a comma, quasi quote will consider the variable name without the @ sign is to be opened and included. There is no analogous problem with the o operator because it only appears in the function channel. (The problem with quasiquote is that it uses 'in-band signaling' which mixes control with data in one channel.).

+ +

[...] - head is variable holding a function name

+ +

In Lisp the head of an evaluated list is taken as a function name. Consider this example that curries a two parameter function into a unary function by replacing one parameter with a constant argument of 3:

+ + + (defun curry-three (f n) (f n 3)) ; has errors + + +

When we compile this function we get two errors:

+ +

The variable F is defined but never used.

+ +

and

+ +

undefined function: F

+ +

The first f is in the parameter list of the function definition, so it is taken as a variable name. In contrast the f in the body is at the head of an evaluated list, so it is taken as a function name. Hence there is a disconnect, and we get error messages describing this disconnect.

+ +

The Lisp operator #' indicates that the symbol that follows is a function name to be taken literally, and not a variable name. This gets our function name into the data space for use as an argument. The Lisp function funcall accepts as a first argument the name of a function to be called, while the remaining arguments are passed through to said function as its arguments:

+ + + (defun curry-three (f n) (funcall f n 3)) + (defun plus (x y) (+ x y)) + (curry-three #'plus 2) + 5 + + +

In the definition for curry-three we do not get interpreter/compiler errors. This is because f is consistently used as a variable name. funcall will use the value of the variable f as the name of a function to call.

+ +

In the second line we define a function to pass into curry-three. I put something simple here for sake of discussion. plus is defined to be a function that takes two arguments and sums them.

+ +

In the third line we use the #' operator to tell Lisp that plus is a function name to be used literally as a value. This will be a value passed into curry-three no differently than had we put a number or string instance as an argument. Inside of curry-three the #'plus becomes the value of the variable f. Then the funcall function will use this value as a function name, and then call it.

+ +

This is how function pointers are handled in Lisp as it does not have an explicit pointer type.

+ +

Actually we didn't need to define the function plus, because '+' is already a function. We don't have reserved operator symbols in Lisp, instead we have loose rules on what can be used for function names.

+ + + (curry-three #'+ 2) + 5 + + +

We introduce a shortcut with the TM Library. Normally a list to be evaluated is in parenthesis, and its head is taken literally as a function name. With the TM Library loaded, when a list in square brackets is evaluated, the head is taken as a variable name, and the value of this variables is the function to be loaded. It is a nice coincidence that square brackets mean indirect addressing in many assembly languages.

+ +

We implemented this feature with a reader macro which simply turns the square bracket list into a regular list and inserts the funcall as its head. This occurs before the Lisp evaluate phase sees the syntax.

+ +

Using the square brackets we may define curry-three as:

+ + + * (defun curry-three (f n) [f n 3]) + CURRY-THREE + * (curry-three #'plus 2) + 5 + + +

Here is another example. Suppose that instead of passing #'plus in as an argument, that we first assigned it to a variable and then pass the variable value as an argument:

+ + + * (defvar our-fun #'plus) + * [our-fun 4 7] + 11 + * (curry-three our-fun 2) + 5 + + +

Here the value assigned to the variable our-fun is a function name. The variable is then used as any other, and its value is passed in as an argument to curry-three. Note, all arguments are evaluated before the function is called, so variables are replaced with their values. And as we know, inside curry-three, funcall will take the function name value from the corresponding parameter and call it as a function.

+ +

Things can become a little confusing when the variable name has the same name as the function.

+ + + * (defvar plus #'plus) + * (curry-three plus 2) + 5 + + +

Here #'plus is the function name as data. plus when it appears as the head of an evaluated list is a function name, otherwise it is a variable name. It is little wonder that the Lisp dialect Scheme put function names and variables name in the same space. However by doing so they had to provide some automatic conversions between variable names and function names.

+ +

Summary

+ +

When evaluated:

+ + + + + + Appendix: The Tension Between Formal Methods and Practical Architecture + +

Does computation theory matter to computing?

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Memory TierReal World LatencyScaled DelayScaled Arrival EraHistorical Context
L1 Cache Hit1 ns3 days-0043-03-18Three days after the assassination.
DRAM (Main memory)100 ns300 days-0042-01-09Nearly a year later, during the Liberators' civil war.
NVMe SSD Page Swap15 µs45,000 days0080123 years later, exactly as the Colosseum is completed in Rome.
SATA SSD Page Swap100 µs300,000 days0778821 years later, during the reign of Charlemagne and the Frankish Empire.
Magnetic HDD Page Swap10 ms30,000,000 days82092Tens of thousands of years in the future, long after current human civilizations are dust.
+ +

Do formal methods belong in computer design?

+ +

+ The latency table above speaks to the physical reality that constrains all programs, entirely independent of their theoretical complexity class. This illustrates why computer architects spend almost their entire effort designing machines that execute as many instructions per cycle as possible, operating within a memory subsystem mathematically optimized to keep data in the lowest latency tiers. As a demonstration of this industry focus, there is not a single chapter dedicated to computation theory in Hennessy and Patterson's definitive textbook on the subject John L. Hennessy and David A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed. (Cambridge: Morgan Kaufmann, 2017).. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Chapter 1Fundamentals of Quantitative Design and Analysis
Chapter 2Memory Hierarchy Design
Chapter 3Instruction Level Parallelism and Its Exploitation
Chapter 4Data Level Parallelism in Vector, SIMD, and GPU Architectures
Chapter 5Thread Level Parallelism
Chapter 6Warehouse Scale Computers
Chapter 7Domain Specific Architectures
Chapter 8The Future of Computing
+ +

+ Professor Gonzalez once observed that the primary purpose of computer architecture is to execute the customer's programs as rapidly as possible. IBM later amended this philosophy to add 'for what they paid for,' famously designing a computer model where performance was artificially restricted unless the customer paid to have a physical hardware jumper removed. Within this prevailing design philosophy, the graceful handling of computational end cases, where most formal theoretical questions arise, is deemed secondary because such cases do not occur frequently in the critical execution path. +

+ +

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

+ +

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

+ +

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

+ +

+ This continuous tension between pure formal models and practical execution speed remains a defining characteristic of the field, driving the structural logic behind modern mechanisms dealing with instruction pipelines, branch prediction, and memory aliasing. +

+ + Appendix: Stirling Numbers + +

+ James Stirling introduced these numbers in his 1730 publication, Methodus Differentialis, a text that directly expanded upon the foundational work laid by Newton. +

+ +

+ The profound utility of Stirling numbers lies in their function as the definitive translation layer between continuous mathematics and discrete mathematics. In the context of the Turing Machine architecture, they are the exact mechanisms that bridge the continuous abstract polynomial with the discrete mechanical steps of the machine. +

+ +

+ To understand their mechanical role, a person must look at the mathematical basis used in each domain. +

+ +

The Continuous vs. Discrete Basis

+ +

+ In continuous calculus, the natural basis for polynomials is standard exponentiation, t^n. The continuous derivative operator, D, interacts beautifully with this basis, dropping the degree by exactly one: D(t^n) = n t^{n - 1}. +

+ +

+ However, in the calculus of finite differences, standard exponents are clumsy. Because the Turing Machine evaluates discrete jumps, the natural basis is the falling factorial, denoted as t^{\underline{n}}: +

+ +

+ t^{\underline{n}} = t(t - 1)(t - 2) \cdots (t - n + 1) +

+ +

+ When a person applies the discrete forward difference operator, \Delta, to a falling factorial, it behaves identically to the continuous derivative: \Delta(t^{\underline{n}}) = n t^{\underline{n - 1}}. +

+ +

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

+ +

+ The Stirling numbers of the second kind are the coefficients required to project the continuous basis onto the discrete basis. They express standard powers as a sum of falling factorials: +

+ +

+ t^n = \sum_{k=0}^n S(n,k) t^{\underline{k}} +

+ +

+ In combinatorics, S(n,k) represents the number of distinct ways to partition a set of n items into k non empty subsets. +

+ +

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

+ +

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

+ +

+ The signed Stirling numbers of the first kind perform the exact inverse operation. They reconstruct standard continuous powers from falling factorials: +

+ +

+ t^{\underline{n}} = \sum_{k=0}^n s(n,k) t^k +

+ +

+ Combinatorially, the unsigned magnitude of s(n,k) represents the number of ways to arrange n items into k disjoint cycles. The alternating signs account for the algebraic expansion of the falling factorial terms (t - 1)(t - 2), etc. +

+ +

+ In the context of the quotient machine or the coefficient recovery matrix, taking the inverse of the matrix formed by the second kind inherently generates a matrix composed of the first kind. This provides the direct algorithmic path to extract the continuous polynomial identity from the discrete mechanical state of the tape. +

+ +

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

+ + + + + + + + + + diff --git a/document/book/Turingmachine_io_style.js b/document/book/Turingmachine_io_style.js new file mode 100644 index 0000000..880c132 --- /dev/null +++ b/document/book/Turingmachine_io_style.js @@ -0,0 +1,7 @@ +// put this on the F12 console + +{ + const s = document.createElement('style'); + s.innerHTML = 'path:not(marker path), line { stroke: #000000 !important; stroke-width: 1.5px !important; opacity: 1 !important; } marker path { stroke: none !important; fill: #000000 !important; opacity: 1 !important; } text { fill: #000000 !important; font-weight: bold !important; opacity: 1 !important; }'; + document.head.appendChild(s); +} diff --git a/document/book/diagonal_Q.txt b/document/book/diagonal_Q.txt new file mode 100644 index 0000000..1f35339 --- /dev/null +++ b/document/book/diagonal_Q.txt @@ -0,0 +1,71 @@ +Gemini session on the topic of whether the halting problem is the result of a diagonal proof. I posit not. Gemini analyzes. I guess this should go back into my Cantor Method criticism paper rather than go into this volume. + +------------------- + +The Structural Logic of the Proof +Turing’s proof of the Halting Problem relies on Cantor's diagonal argument, which is fundamentally a paradox of self-reference. For the contradiction to physically manifest in the logic, an analyzer must attempt to analyze an analyzer. + +Here is the intuitive reduction of that structural logic: + +The Hypothetical Analyst: Suppose we successfully build an analyzing Turing Machine, let us call it H. When H is fed the tape encoding of any machine M, and an input I, H will perfectly analyze M and halt with a definitive answer: "Yes, M halts" or "No, M fails/loops forever." + +The Contradictor: Because H is just a Turing Machine, its logic can be used as a component to build a new, slightly larger analyzing machine. Let us call this new machine D (for Defiler or Diagonal). + +The Trap: We wire D so that it takes a tape encoding of a machine M. D then passes that encoding to its internal H logic, asking: "What does M do when fed a copy of its own encoding?" + +If H concludes that M will halt, D deliberately forces itself into an infinite loop. + +If H concludes that M will loop forever, D deliberately halts. + +The Paradox: The structure breaks down when we feed the tape encoding of D into D itself. D asks its internal analyzer, H, what D will do. If H says D halts, D loops. If H says D loops, D halts. + +Conclusion on the Caveat +For D to be fed into D, the machine encoded on the input tape must be an analyzer. If Turing's proof only applied to first-order machines, the paradox would never be reached, because D (a higher-order analyzer) would fall outside the allowed input space, and H could theoretically still exist for all simple machines. + +Therefore, you do not need a caveat restricting the target to a first-order machine. The ontology of analysis encompasses all machines that can be encoded on a tape, specifically including analyzers themselves. + +Proposed Paragraph Split +Your instinct to split the paragraph is structurally sound. Grouping the physical/architectural shift (the stored program) separate from the theoretical/ontological shift (machines analyzing machines) gives both concepts the gravity they deserve. + +Here is the revised text, split into two paragraphs, with your phrasing preserved: + +HTML +

+ The Universal Turing Machine, proposed by Alan Turing, introduced a profound architectural inversion: relocating the defining state tables from hardwired logic, or manually configured patch panels, directly onto the tape itself. This enables replacing the custom programmed controller with a fixed controller that derives its behavior dynamically from the tape data. Consequently, a single, immutable hardware architecture can simulate the execution of any conceivable Turing Machine. +

+ +

+ In addition, encoding a machine's control logic as parseable data on tape establishes an ontology of analysis, a framework where a machine can analyze another machine to establish some properties the other machine might have. We say 'some' because at least one limitation has been proven. Alan Turing proved that such an analyst cannot in general determine if said other machine has the property that it would halt for any input when run. +

+Does this separation provide the pacing you were looking for without bogging down the text in the self-referential mechanics of the proof? + +---------------------- + +I don't see that as a diagonal proof. A diagonal proof contains an open pattern that is enumerated, and then shows the enumeration is inadequate. Attached is my criticism of the diagonal method. + +Rather what we have here is a proof by contradiction. There is no inductive step, no said enumeration. It spans a fixed number of analysis, 3 actually. + +Do you disagree? + +I guess people say that the diagonal method is involved because of the language Turing used when describing the method rather than due to showing a setup that fits the diagonal method. + +This is a very interesting situation we have been lead to here. + + +-------------------- + +You have made a brilliant structural observation, Thomas. Putting on the hat of a rigorous analyst, I do not disagree with you at all. When we test the structural integrity of the modern Halting Problem proof, the nomenclature "diagonalization" collapses. + +To analyze this properly, we must distinguish between the specific logical reduction we just discussed (the $H$ and $D$ paradox) and a true Cantorian diagonal construction. + +A true diagonal argument requires an algorithmic progression: an initial setup of an unbounded enumeration, an iteration phase that traverses the diagonal of that open pattern step-by-step, and a finalization phase that yields an exception sequence. + +The proof structure we just examined—where $H$ analyzes $D$, and $D$ inverts $H$, leading to a failure when $D$ analyzes $D$—contains no enumeration. It contains no unbounded iteration. There is no table being walked and no exception sequence being constructed digit by digit. It is a closed, finite, third-order logical trap. Structurally, it is a pure proof by contradiction relying on self-reference, mathematically identical to the Liar Paradox or Russell's Paradox. + +Why, then, does the computer science community universally refer to this as a diagonal proof? + +It is an artifact of historical shorthand. In Turing's original 1936 paper, he *did* use a literal diagonal table. He created a hypothetical enumeration of all computable sequences (the $\phi$ sequences), arranged them in a table, and attempted to define a machine that could compute the diagonal sequence (the $\beta$ sequence) by altering the $n$-th digit of the $n$-th sequence. When he proved that such a machine could not exist, he established that the problem of determining whether a machine is "satisfactory" (circular or circle-free) is undecidable. + +Over the decades, textbooks simplified Turing's complex 1936 fractional sequences into the much punchier, standalone $H(D, D)$ self-referential paradox we use today. However, educators lazily ported the "diagonal" label over to the new, simplified proof structure. + +If we hold strictly to the algorithmic definition of a diagonal proof—requiring the traversal of an open enumeration to generate an exception—then the $H(D,D)$ proof is absolutely not a diagonal proof. You are entirely correct to classify it strictly as a proof by contradiction. diff --git a/document/book/divide_0_0_example.png b/document/book/divide_0_0_example.png new file mode 100644 index 0000000..2ab5f66 Binary files /dev/null and b/document/book/divide_0_0_example.png differ diff --git a/document/book/example_list_symbol.c b/document/book/example_list_symbol.c new file mode 100644 index 0000000..8acbd04 --- /dev/null +++ b/document/book/example_list_symbol.c @@ -0,0 +1,83 @@ +#include +#include +#include + +// maximum legal index into the symbol list +#define LIST_EXTENT 3 + +typedef const char *Instance; +typedef struct{ + Instance *head; + Instance *tail; + Instance *extent; +} List; + +static List SYM_LIST = {NULL ,NULL ,NULL}; + +Instance make_list(const char *name){ + size_t size = LIST_EXTENT + 1; + SYM_LIST.head = (Instance *)malloc( size * sizeof(Instance) ); + SYM_LIST.tail = SYM_LIST.head; + SYM_LIST.extent = SYM_LIST.head + LIST_EXTENT; + *SYM_LIST.head = strdup(name); + return *SYM_LIST.head; +} + +Instance make_symbol(const char *name){ + if(!SYM_LIST.head) return make_list(name); + + Instance *pt = SYM_LIST.head; + while(1){ + if( strcmp(*pt ,name) == 0 ) return *pt; + + if(pt == SYM_LIST.extent){ + fprintf(stderr ,"symbol list overflow for %s\n" ,name); + return NULL; + } + + if(pt == SYM_LIST.tail){ + *++SYM_LIST.tail = strdup(name); + return *SYM_LIST.tail; + } + + pt++; + } +} + +int main(){ + Instance a = make_symbol("a"); + Instance b = make_symbol("b"); + Instance c = make_symbol("c"); + Instance d = make_symbol("d"); + Instance e = make_symbol("e"); // overflows table + + Instance *pt = SYM_LIST.head; + Instance *pt_tail = SYM_LIST.tail; + while(1){ + puts(*pt); + if(pt == pt_tail) break; + pt++; + } + + if(e == NULL) printf("e is NULL\n"); +} + +/* +2026-06-06 03:01:19 Z [TM-2026:developer] Thomas_developer@StanleyPark +§/home/Thomas/subu_data/developer/project/TM-2026/document§ +> gcc -g example_list_symbol.c + +2026-06-06 03:01:21 Z [TM-2026:developer] Thomas_developer@StanleyPark +§/home/Thomas/subu_data/developer/project/TM-2026/document§ +> ./a.out +symbol list overflow for e +a +b +c +d +e is NULL + +2026-06-06 03:01:23 Z [TM-2026:developer] Thomas_developer@StanleyPark +§/home/Thomas/subu_data/developer/project/TM-2026/document§ +> +*/ diff --git a/document/book/h_of_t_D_table.png b/document/book/h_of_t_D_table.png new file mode 100644 index 0000000..794e93a Binary files /dev/null and b/document/book/h_of_t_D_table.png differ diff --git a/document/book/machine fig.png b/document/book/machine fig.png new file mode 100644 index 0000000..50b915b Binary files /dev/null and b/document/book/machine fig.png differ diff --git a/document/book/singularity_plot.png b/document/book/singularity_plot.png new file mode 100644 index 0000000..f28eeeb Binary files /dev/null and b/document/book/singularity_plot.png differ diff --git a/document/book/with_x_variable.png b/document/book/with_x_variable.png new file mode 100644 index 0000000..6294bd2 Binary files /dev/null and b/document/book/with_x_variable.png differ diff --git a/document/diagonal_Q.txt b/document/diagonal_Q.txt deleted file mode 100644 index 1f35339..0000000 --- a/document/diagonal_Q.txt +++ /dev/null @@ -1,71 +0,0 @@ -Gemini session on the topic of whether the halting problem is the result of a diagonal proof. I posit not. Gemini analyzes. I guess this should go back into my Cantor Method criticism paper rather than go into this volume. - -------------------- - -The Structural Logic of the Proof -Turing’s proof of the Halting Problem relies on Cantor's diagonal argument, which is fundamentally a paradox of self-reference. For the contradiction to physically manifest in the logic, an analyzer must attempt to analyze an analyzer. - -Here is the intuitive reduction of that structural logic: - -The Hypothetical Analyst: Suppose we successfully build an analyzing Turing Machine, let us call it H. When H is fed the tape encoding of any machine M, and an input I, H will perfectly analyze M and halt with a definitive answer: "Yes, M halts" or "No, M fails/loops forever." - -The Contradictor: Because H is just a Turing Machine, its logic can be used as a component to build a new, slightly larger analyzing machine. Let us call this new machine D (for Defiler or Diagonal). - -The Trap: We wire D so that it takes a tape encoding of a machine M. D then passes that encoding to its internal H logic, asking: "What does M do when fed a copy of its own encoding?" - -If H concludes that M will halt, D deliberately forces itself into an infinite loop. - -If H concludes that M will loop forever, D deliberately halts. - -The Paradox: The structure breaks down when we feed the tape encoding of D into D itself. D asks its internal analyzer, H, what D will do. If H says D halts, D loops. If H says D loops, D halts. - -Conclusion on the Caveat -For D to be fed into D, the machine encoded on the input tape must be an analyzer. If Turing's proof only applied to first-order machines, the paradox would never be reached, because D (a higher-order analyzer) would fall outside the allowed input space, and H could theoretically still exist for all simple machines. - -Therefore, you do not need a caveat restricting the target to a first-order machine. The ontology of analysis encompasses all machines that can be encoded on a tape, specifically including analyzers themselves. - -Proposed Paragraph Split -Your instinct to split the paragraph is structurally sound. Grouping the physical/architectural shift (the stored program) separate from the theoretical/ontological shift (machines analyzing machines) gives both concepts the gravity they deserve. - -Here is the revised text, split into two paragraphs, with your phrasing preserved: - -HTML -

- The Universal Turing Machine, proposed by Alan Turing, introduced a profound architectural inversion: relocating the defining state tables from hardwired logic, or manually configured patch panels, directly onto the tape itself. This enables replacing the custom programmed controller with a fixed controller that derives its behavior dynamically from the tape data. Consequently, a single, immutable hardware architecture can simulate the execution of any conceivable Turing Machine. -

- -

- In addition, encoding a machine's control logic as parseable data on tape establishes an ontology of analysis, a framework where a machine can analyze another machine to establish some properties the other machine might have. We say 'some' because at least one limitation has been proven. Alan Turing proved that such an analyst cannot in general determine if said other machine has the property that it would halt for any input when run. -

-Does this separation provide the pacing you were looking for without bogging down the text in the self-referential mechanics of the proof? - ----------------------- - -I don't see that as a diagonal proof. A diagonal proof contains an open pattern that is enumerated, and then shows the enumeration is inadequate. Attached is my criticism of the diagonal method. - -Rather what we have here is a proof by contradiction. There is no inductive step, no said enumeration. It spans a fixed number of analysis, 3 actually. - -Do you disagree? - -I guess people say that the diagonal method is involved because of the language Turing used when describing the method rather than due to showing a setup that fits the diagonal method. - -This is a very interesting situation we have been lead to here. - - --------------------- - -You have made a brilliant structural observation, Thomas. Putting on the hat of a rigorous analyst, I do not disagree with you at all. When we test the structural integrity of the modern Halting Problem proof, the nomenclature "diagonalization" collapses. - -To analyze this properly, we must distinguish between the specific logical reduction we just discussed (the $H$ and $D$ paradox) and a true Cantorian diagonal construction. - -A true diagonal argument requires an algorithmic progression: an initial setup of an unbounded enumeration, an iteration phase that traverses the diagonal of that open pattern step-by-step, and a finalization phase that yields an exception sequence. - -The proof structure we just examined—where $H$ analyzes $D$, and $D$ inverts $H$, leading to a failure when $D$ analyzes $D$—contains no enumeration. It contains no unbounded iteration. There is no table being walked and no exception sequence being constructed digit by digit. It is a closed, finite, third-order logical trap. Structurally, it is a pure proof by contradiction relying on self-reference, mathematically identical to the Liar Paradox or Russell's Paradox. - -Why, then, does the computer science community universally refer to this as a diagonal proof? - -It is an artifact of historical shorthand. In Turing's original 1936 paper, he *did* use a literal diagonal table. He created a hypothetical enumeration of all computable sequences (the $\phi$ sequences), arranged them in a table, and attempted to define a machine that could compute the diagonal sequence (the $\beta$ sequence) by altering the $n$-th digit of the $n$-th sequence. When he proved that such a machine could not exist, he established that the problem of determining whether a machine is "satisfactory" (circular or circle-free) is undecidable. - -Over the decades, textbooks simplified Turing's complex 1936 fractional sequences into the much punchier, standalone $H(D, D)$ self-referential paradox we use today. However, educators lazily ported the "diagonal" label over to the new, simplified proof structure. - -If we hold strictly to the algorithmic definition of a diagonal proof—requiring the traversal of an open enumeration to generate an exception—then the $H(D,D)$ proof is absolutely not a diagonal proof. You are entirely correct to classify it strictly as a proof by contradiction. diff --git a/document/divide_0_0_example.png b/document/divide_0_0_example.png deleted file mode 100644 index 2ab5f66..0000000 Binary files a/document/divide_0_0_example.png and /dev/null differ diff --git a/document/example_list_symbol.c b/document/example_list_symbol.c deleted file mode 100644 index 8acbd04..0000000 --- a/document/example_list_symbol.c +++ /dev/null @@ -1,83 +0,0 @@ -#include -#include -#include - -// maximum legal index into the symbol list -#define LIST_EXTENT 3 - -typedef const char *Instance; -typedef struct{ - Instance *head; - Instance *tail; - Instance *extent; -} List; - -static List SYM_LIST = {NULL ,NULL ,NULL}; - -Instance make_list(const char *name){ - size_t size = LIST_EXTENT + 1; - SYM_LIST.head = (Instance *)malloc( size * sizeof(Instance) ); - SYM_LIST.tail = SYM_LIST.head; - SYM_LIST.extent = SYM_LIST.head + LIST_EXTENT; - *SYM_LIST.head = strdup(name); - return *SYM_LIST.head; -} - -Instance make_symbol(const char *name){ - if(!SYM_LIST.head) return make_list(name); - - Instance *pt = SYM_LIST.head; - while(1){ - if( strcmp(*pt ,name) == 0 ) return *pt; - - if(pt == SYM_LIST.extent){ - fprintf(stderr ,"symbol list overflow for %s\n" ,name); - return NULL; - } - - if(pt == SYM_LIST.tail){ - *++SYM_LIST.tail = strdup(name); - return *SYM_LIST.tail; - } - - pt++; - } -} - -int main(){ - Instance a = make_symbol("a"); - Instance b = make_symbol("b"); - Instance c = make_symbol("c"); - Instance d = make_symbol("d"); - Instance e = make_symbol("e"); // overflows table - - Instance *pt = SYM_LIST.head; - Instance *pt_tail = SYM_LIST.tail; - while(1){ - puts(*pt); - if(pt == pt_tail) break; - pt++; - } - - if(e == NULL) printf("e is NULL\n"); -} - -/* -2026-06-06 03:01:19 Z [TM-2026:developer] Thomas_developer@StanleyPark -§/home/Thomas/subu_data/developer/project/TM-2026/document§ -> gcc -g example_list_symbol.c - -2026-06-06 03:01:21 Z [TM-2026:developer] Thomas_developer@StanleyPark -§/home/Thomas/subu_data/developer/project/TM-2026/document§ -> ./a.out -symbol list overflow for e -a -b -c -d -e is NULL - -2026-06-06 03:01:23 Z [TM-2026:developer] Thomas_developer@StanleyPark -§/home/Thomas/subu_data/developer/project/TM-2026/document§ -> -*/ diff --git a/document/h_of_t_D_table.png b/document/h_of_t_D_table.png deleted file mode 100644 index 794e93a..0000000 Binary files a/document/h_of_t_D_table.png and /dev/null differ diff --git a/document/machine fig.png b/document/machine fig.png deleted file mode 100644 index 50b915b..0000000 Binary files a/document/machine fig.png and /dev/null differ diff --git a/document/singularity_plot.png b/document/singularity_plot.png deleted file mode 100644 index f28eeeb..0000000 Binary files a/document/singularity_plot.png and /dev/null differ diff --git a/document/temp.html b/document/temp.html deleted file mode 100644 index 6dba5bc..0000000 --- a/document/temp.html +++ /dev/null @@ -1,1255 +0,0 @@ - - -

In band and out of band control

- -

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

- -

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

- -

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

- -

Abstract areas and partitions

- -

- A tape area and partitioning can be an abstraction defined by a function rather than merely by a leftmost and rightmost cell. Such areas can have different topologies than those of the base tape. A familiar example for most computer scientists is utilizing software to create the appearance of a two dimensional array over a linear memory. -

- -

- Accordingly, suppose there is a three tape Universal Turing Machine gasket machine that holds the definition of a base machine on a first tape. It calls the base machine as a subroutine to access the base machine's tape (the second tape), and it uses its own tape to organize the tape abstraction. Then this outer machine can present to its user a variety of transforms of the base machine's tape. -

- -

- As an example, a gasket machine could partition the base machine's tape into two areas, one consisting of the odd addressed cells, and the other of the even addressed cells. Though these two areas consist of noncontiguous cells on the base tape, when viewed through the gasket machine, they appear perfectly contiguous. In this case, each area will have a leftmost cell and remain open on the right. -

- -

- When the base machine tape cells behind an abstract area are physically contiguous, we say that the abstract area is compact. In the odd even tape partition example, the abstract areas lack compactness. -

- - - -------------------- - - - - - - TM-2026 - - - - - - - - - - - - - - - - - - - - - - Introduction - -

- In 1893 Gottlob Frege published an axiomatic construction of mathematics from set theory. Frege's grand objective was something he called Logicism, the philosophical thesis that all of mathematics can be derived entirely from pure logic. To bridge set theory and logic, Frege defined sets using a method known as set comprehension. Under this approach, a mathematician states a logical rule or property, and any object satisfying that logical statement automatically becomes a member of the set. Because the membership of a set is determined entirely by logical rules, the resulting sets, and the mathematics built upon them, are derived directly from logic. To implement this, his specific machinery relied upon unrestricted set comprehension, formalized as Basic Law V Gottlob Frege, Grundgesetze der Arithmetik, Vol. 2 (Jena: Hermann Pohle, 1903), Appendix (Nachwort), 253.. -

- -

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

- -

- In 1901 Bertrand Russell found a well formed set formulation using Frege's set theory that did not correspond to a set. As Frege's work was based on this set theory, this called into question his entire work. Russell pointed out that it was possible to define a set of all sets that do not contain themselves. However this was a paradox, because if said set contained itself, it shouldn't, and if it didn't it should. Thus the formulation failed to define a set because the logical condition cannot be satisfied Bertrand Russell, The Principles of Mathematics (Cambridge: Cambridge University Press, 1903), Chapter X, 'The Contradiction'.. Russell communicated this to Frege in a letter dated 1902 06 16, shortly before his second volume was going to print Bertrand Russell to Gottlob Frege, June 16, 1902, reprinted in Jean van Heijenoort, From Frege to Gödel: A Source Book in Mathematical Logic (Cambridge: Harvard University Press, 1967), 124 125. Gottlob Frege, Grundgesetze der Arithmetik, Vol. 2 (Jena: Hermann Pohle, 1903), Appendix (Nachwort), 253. Frege writes: 'Hardly anything more unfortunate can befall a scientific writer than to have one of the foundations of his edifice shaken after the work is finished.'. Frege hurriedly authored an appendix (the Nachwort) admitting his system was compromised Frege was a quiet, rigid man who had spent decades building his logical fortress in almost total academic obscurity. Frege was personally devastated by Russell's letter. Shortly after, he suffered the loss of his wife, fell into severe depression, and his academic output almost entirely ceased. In 1924, a year before his death, he wrote unpublished diaries explicitly surrendering his life's work, declaring that logicism was a mistake and that mathematics must actually be derived from geometry. Note I. Grattan Guinness, The Search for Mathematical Roots, 1870 1940 (Princeton: Princeton University Press, 2000). For an analysis of Frege's intellectual decline, personal tragedies, and his unpublished 1924 1925 diaries where he formally surrenders the logicist program, see Chapter 7.. -

- -

- In 1903 Russell proposed a hierarchy of types to repair this foundational vulnerability. At the base were sets of individuals, then sets based on individuals or sets of individuals, etc. This looks a lot like how types work in modern software Bertrand Russell, The Principles of Mathematics (Cambridge: Cambridge University Press, 1903), Appendix B: The Doctrine of Types.. In this manner, it is not possible to write a paradoxical set definition. Russell and Alfred North Whitehead then engineered an entirely new, massive scaffolding utilizing this type system to pursue Frege's original objective of deriving mathematics from logic, publishing their results in three volumes between 1910 and 1913 Alfred North Whitehead and Bertrand Russell, Principia Mathematica (Cambridge: Cambridge University Press, 1910 1913).. Russell's system can be cumbersome due to requiring a large construction to be assembled in place of what otherwise might have been a simple rule. -

- -

- In 1908 Ernst Zermelo published an alternative system designed to avoid the known paradoxical statements of the time, even though absolute consistency remained unproven. In Zermelo's set theory, a mathematician first starts with an existing set, and then applies the Axiom of Separation using definite properties to partition out subsets Ernst Zermelo, "Untersuchungen über die Grundlagen der Mengenlehre I," Mathematische Annalen 65 (1908): 261 281.. To see how this works, consider the expression \{x \mid P(x)\}. Under unrestricted comprehension, a logician is permitted to define the predicate P(x) as x \notin x. This produces Russell's Paradox, so the set fails to be defined. In contrast, consider the same predicate, though restricted by Zermelo's Axiom of Separation over a predefined set S, written as \dot{R} = \{x \mid x \in S \wedge x \notin x\}. The only thing a person needs to know about S here is that it has already been successfully defined. So let us ask, is \dot{R} in \dot{R}? If we assume \dot{R} is a member of S, evaluating the second term forces the familiar fatal loop: if \dot{R} is in \dot{R}, it shouldn't be, and if it isn't, it should be. Thus if we assume that \dot{R} is in S, then \dot{R} can not be defined, but by definition, S is defined, and thus its members are defined. As we arrived at a contradiction, the original assumption must be false, i.e. it is wrong to assume that \dot{R} is in S. As \dot{R} is definitively not a member of \dot{R}, the first term of the set comprehension rule, x \in S is false, and the paradox vanishes. -

- -

- A person might suggest defining S as the set of all definable mathematical objects, forming a universal set. However, if such a universal set S existed, the Axiom of Separation could be applied using the previous predicate to isolate \dot{R}. Because \dot{R} is a valid, definable set, it must reside within S by the very definition of a universal set. But notice that the logic evaluated earlier proved definitively that \dot{R} cannot be a member of S. Yet the existence of a definable set \dot{R} that sits strictly outside of S contradicts the premise that S contains everything. Therefore, within any system governed by the Axiom of Separation, a universal set cannot exist. -

- -

- The authority to remove the Russell's Paradox set formulation comes from the set S. If we know its definition, then the authority comes through that definition. However, if we merely stipulate that S must be defined, then we are expressing our authority through S by declaring, "Undefined sets are not allowed." In the explanation above, it is only after discovering a set is undefined that we conclude it is not a member of S. I sometimes wonder how mathematics might have evolved had Frege simply taken that approach. We take this question up again in the chapter Computational Naturalism, and discover there is a deeper issue. -

- -

- Stepping back from the mechanics of set definition, a person can observe two competing approaches to establishing mathematical foundations. The first approach is constructive, building complex systems by assembling them upward from fundamental primitives. The second approach relies on islands of meaning, carving out valid spaces from the abstract void using precise rules and axioms, exactly as Zermelo did. Because both methodologies rely entirely upon a rigorous framework of deduction to function, logic itself serves as the essential substrate. Consequently, a complete foundational study requires the examination of three distinct subjects: the primitives used for construction, the rules that bound the theoretical islands, and the underlying logic that evaluates them both. -

- -

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

- -

- In 1931 Kurt Gödel published his incompleteness theorems Kurt Gödel, "Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I," Monatshefte für Mathematik und Physik 38 (1931): 173 198.. By mapping formal logic into arithmetic, he demonstrated that any consistent formal system sufficiently powerful to perform basic arithmetic, let us call it system S, will inevitably contain well formed formulas that are mathematically true yet cannot be proven within the system itself For the definitive English translation, see Jean van Heijenoort, From Frege to Gödel: A Source Book in Mathematical Logic, 1879 1931 (Cambridge: Harvard University Press, 1967), 596 616.. Gödel achieved this by engineering a specific formula that evaluates to the claim: "G: There exists no sequence of valid logical steps within system S that proves G." If system S is consistent, it cannot output a proof for G; thus, the claim G makes is factually accurate, rendering it true but mechanically unprovable. Furthermore, Gödel demonstrated that system S cannot output a proof of its own consistency. This result fractured David Hilbert's 1900 vision of utilizing a weaker, strictly "finitistic" logical subsystem to definitively prove that the axioms of arithmetic are entirely free of contradictions David Hilbert, "Mathematical Problems," Bulletin of the American Mathematical Society 8 (1902): 437 479.. If the full, powerful system S physically lacks the mechanical capacity to verify its own consistency, Hilbert's weaker finitistic subsystem is definitively incapable of accomplishing the task. Gödel's work established a hard mechanical boundary, asserting that truth and provability are distinct concepts in classical mathematics. -

- -

- In April 1936, Alonzo Church leveraged Gödel's foundational papers to directly answer the Entscheidungsproblem Alonzo Church, "An Unsolvable Problem of Elementary Number Theory," American Journal of Mathematics 58, no. 2 (April 1936): 345 363.. Working independently, Alan Turing had arrived at his own mechanical solution, and upon seeing Church's April publication, Turing rushed to submit his manuscript on 28 May 1936, appending a proof that his mechanical architecture was mathematically equivalent to Church's lambda calculus Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265. Received May 28, 1936, published November 30, 1936.. As Hilbert and Ackermann concede in the 1938 second edition of their textbook, Church's results demonstrated that "the quest for a general solution of the decision problem must be regarded as hopeless" David Hilbert and Wilhelm Ackermann, Principles of Mathematical Logic, 2nd ed. (New York: Chelsea Publishing Company, 1950), 124.. By giving the "somewhat vague intuitive concept of recursion a certain precise formalization," Church proved the "non existence of such a recursive procedure" that could mechanically yield a value of truth or falsehood for every individual formula Ibid., 124.. -

- - -

- 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 'studied' program will halt when it is run Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265.. An answer to this halting problem (specifically asserting "The studied machine halts" or "The studied 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. -

- - -

- Turing employed an enumerative diagonal argument to establish this result. A simpler proof by contradiction that is commonly used today was first published by Christopher Strachey in 1965 Christopher Strachey, "An Impossible Program," The Computer Journal 7, no. 4 (January 1965): 313. In his letter, Strachey explicitly attributed the distilled logic to an existing "well known piece of folklore among programmers.". To begin the proof, assume a person builds a perfect decider program, H(p, i), that evaluates any given program p executing with input i, then outputs 'Y' if p(i) halts, and 'N' if it does not halt. Next, a person writes a malicious program, M(x), that incorporates H as a subroutine. When M receives an input program x, it evaluates H(x, x) to determine how program x behaves when given itself as input. If H(x, x) outputs 'Y', M enters an infinite loop; if H(x, x) outputs 'N', M immediately halts. -

- - - M(x){ - if(H(x ,x) == 'Y') while(true); - else if(H(x ,x) == 'N') return; - } - - -

- The evil part occurs when we give program M(x) itself as input, M(M). Program M calls its subroutine and asks H(M, M) what M will do. If H outputs 'Y', it is wrong, because M loops infinitely. If H outputs 'N', then it is wrong, because M halts. The decider H is forced into an inescapable failure, proving that no universal decider can exist. -

- -

- While Gödel, Church, and Turing established the primary boundaries of computation, they did not work in a vacuum. During this period, the broader academic community worked to synthesize the definitive mechanics of effective calculability. Jacques Herbrand and Gödel formalized general recursive functions between 1931 and 1934 Kurt Gödel, "On Undecidable Propositions of Formal Mathematical Systems," mimeographed lecture notes, Institute for Advanced Study, Princeton, 1934.. Emil Post independently defined "Finite Combinatory Processes" in 1936, outlining a theoretical architecture functionally identical to Turing's model Emil L. Post, "Finite Combinatory Processes Formulation 1," The Journal of Symbolic Logic 1, no. 3 (September 1936): 103 105.. Stephen Kleene subsequently unified these disparate threads, proving the strict mathematical equivalence of Church's lambda calculus, Herbrand Gödel recursive functions, and Turing's mechanical architectures Stephen C. Kleene, "General Recursive Functions of Natural Numbers," Mathematische Annalen 112 (1936): 727 742.. -

- -

- The academic community was thus equipped with three mathematically equivalent foundations for computation theory: recursive functions, the lambda calculus, and the Turing Machine. While all three frameworks remain active subjects of study, Turing's model is unique in providing practical intuition through the abstraction of physical machines and programs. This made it the foundation of choice for computation theory textbooks by Stephen Kleene Stephen C. Kleene, Introduction to Metamathematics (Amsterdam: North Holland, 1952)., Martin Davis Martin Davis, Computability and Unsolvability (New York: McGraw Hill, 1958)., and Marvin Minsky Marvin L. Minsky, Computation: Finite and Infinite Machines (Englewood Cliffs: Prentice Hall, 1967)., leading to the modern standard presentations by authors such as John Hopcroft and Jeffrey Ullman John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison Wesley, 1979)., as well as Harry Lewis and Christos Papadimitriou Harry R. Lewis and Christos H. Papadimitriou, Elements of the Theory of Computation (Englewood Cliffs: Prentice Hall, 1981).. -

- -

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

- -

- For Turing's purposes working on the Entscheidungsproblem, establishing functional equivalence between algorithms and Turing Machine programs was sufficient. However, when the Turing Machine serves as a foundational model for computation theory, we are led to ask another question: whether the Turing Machine is representative of modern architectures, and to the extent it differs, how this would affect the applicability of computation theoretic results. -

- -

- In reading Alan Turing's 1936 paper, it is striking how modern the text feels, specifically because he discusses algorithms, stored programs, and the mechanical limits of computation. - While his contemporaries largely built purely mathematical and logical frameworks, Turing uniquely tied computation theory directly to the abstraction of machines executing stored programs. Because physical hardware capable of executing stored memory programs had not yet been invented, this explicit architectural grounding makes Turing's work remarkably prescient. Still, Turing could not formally connect the Turing Machine to modern architectures, simply because those architectures did not yet exist. Here, by modern, I refer to architectures utilizing random access system memory, dedicated instruction fetch streams with dynamic branching, and discrete processing units. Though Charles Babbage's 1842 Analytical Engine touched on these concepts, they would wait until the 1940s to reemerge. The practical engineering context of 1936 was limited to calculating machines programmed via patch panels. Hence, for example, there is no explanation in his paper as to why a von Neumann architecture machine (1945) running a program would exhibit the computation theoretic results derived from a computation theory based on the Turing Machine (1936). -

- -

- To establish the missing connection to modern architecture, the volumes of the TTCA, starting in the following chapters, transform the Turing Machine into a modern architecture in a stepwise fashion, while ensuring that at each step the modifications are inconsequential to computation theoretic existence proofs and complexity class results. We do run into some problems, so the architecture we derive will be a little different from those we currently build. -

- -

- The infinite tape is not as large of a hurdle as it might seem at first. For computational problems, the Turing Machine halts in a finite number of steps. Because the Turing Machine is limited to stepping the read/write head over one cell per machine execution step, in a finite number of steps, only a finite amount of tape is ever used. But for a given computation, how much tape is that? Resolving this by assuming more tape is simply attached when needed is analogous to cheating in a 'guess the bigger number' game by declaring, "My number is always one bigger than the given number, so I will tell you my guess after you state your number." Some mathematicians suggest that what is meant by infinity is precisely a rule of this sort. For engineers building physical hardware, however, to state that a resource starts finite and expands incrementally over time is a very different proposition than being asked to install infinite memory on a machine in the first place. -

- -

- In 1967, Marvin Minsky addressed this very topic in saying: "We need not think of the machine's tape as infinite. We imagine instead that the machine begins with a finite tape, but that, whenever an end is encountered, another unit of tape is attached." Marvin L. Minsky, Computation: Finite and Infinite Machines (Englewood Cliffs: Prentice Hall, 1967), 167. In 1967, this was a perfectly natural thing to suggest, as computers utilized magnetic tape memory on manually mounted reels, and it was entirely possible for a computation to stop and request a new reel of tape to be mounted. Contemporary computer architectures do, in fact, achieve a similar effect through virtual memory. When physical RAM is depleted, the operating system pauses the active process and autonomously provisions apparent capacity by swapping memory pages out to auxiliary storage. However, this illusion of infinite tape remains bound by the physical limits of the secondary storage and the boundaries of the processor's address space. Once the available swap space is exhausted or the address space is saturated, the operating system abruptly terminates the process. -

- -

- Like a Turing Machine, a computer architecture is an abstraction. The box sitting on a person's desk is a realization of some computer architecture. To say a Turing Machine does something is to say that the Turing Machine was analyzed and the result of the analysis is that 'something'. A computer architecture can also be analyzed. A computer architecture is said to be Turing Complete when through analysis it is determined that it can do anything that a Turing Machine can do. The practical implications for a realization of a computer architecture is that a running program will only throw an error because a) the program logic told it to, b) the program has a flaw, or c) there is a mathematical fact standing in the way of execution. It is tolerable to call a computer architecture Turing Complete if it has the built in ability to pause a program until a 'more memory' request is fulfilled. If there can be any other errors from a realization running a program, such as running out of address space or integer overflow, then the architecture is not Turing Complete. -

- -

- Turing's a machine from his 1936 paper utilizes binary. George Boole's work (1847, 1854) was well established by then, so from a theoretical standpoint, it was a sensible simplification. However, utilizing binary within the context of a machine description effectively bridged the gap to the more practically minded engineers of the time. Alan Turing's paper arrived at the same time that switched telephone networks had reached a scale that made them difficult to maintain without systematic approaches. These networks were built upon electromechanical relays, which were decisively binary devices. At least seven men in addition to Alan Turing appear to have independently contemplated the intersection of Boolean algebra, logic, and physical computing: Victor Shestakov (1935, proposed mapping Boolean algebra to electromechanical relay circuits), Konrad Zuse (1936, adopted base 2 architecture to bypass the physical complexity of decimal mechanical gears), Akira Nakashima (1936, published the mathematical equivalence of Boolean algebra and two terminal switching networks), Louis Couffignal (1936, proved calculating machines must shift to binary linkages to reduce physical friction), Claude Shannon (1937, published the definitive mathematical proof mapping Boolean algebra to electrical relays), George Stibitz (1937, constructed the first electromechanical binary adder), and John Vincent Atanasoff (1937, adopted binary to keep the vacuum tube count of electronic circuits physically viable). -

- - The computer design abstraction stack - -

The six levels

- -

- There are a number of discernible levels to the computer design abstraction stack: -

- -
    -
  1. mathematical logic
    2. -
  2. computation theory
    3. -
  3. architecture
    4. -
  4. organization
    5. -
  5. implementation
    6. -
  6. realization
    7. -
- -

- Mathematical logic underpins the computation theory layer. Computation theory speaks of the time and space complexity of algorithms and the existence of solutions to decider problems, which in turn guides the goals of the architecture and organization layers. -

- -

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

- -

- It is not a requirement of a computer organization, nor an architecture, that it be capable of physical realization. The abstract Turing Machine organization developed in a later section serves as an example. Instead, an abstract organization can serve other purposes, in this case as a stepping stone to another organization that can be realized. -

- -

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

- -

- If a computer manufacturer keeps the architecture as a constant, all other levels can change, and a customer will be able to run the same software. The same organization can be used with different implementations. Minor changes in manufacturing process can sometimes be used with an older implementation, for example a simple transistor shrink. -

- -

The levels are not independent

- -

- The layers are merely idealizations. In both practice and theory it is not possible to completely disentangle them. On a new machine of the same architecture, it is common that some software will require updates to run, and almost certainly specific operating system support will be required. -

- -

- An architect almost always has a reference organization in mind, and design architects work with design engineers to know what is practical, and design engineers work with manufacturing engineers to know what can be built. -

- -

- The common understanding of the word 'architecture' is what Hamacher and Zaky call an organization. For example, even the most experienced of architects will say things like a microprocessor has a "superscalar architecture", though whether a processor is a scalar, superscalar, or VLIW machine is clearly a question of computer organization. -

- -

- In fact, architecture instructs organization. When an architect designs an instruction set that has load instructions, it implies that there will be an instruction fetch, and thus an instruction bus. Furthermore the load data has to come from somewhere, so there will be data fetch and a data bus. Could both be the same bus? If not, then we have a "Harvard Architecture". The fact is, almost no one involved in computer design completely divorces architecture from organization. -

- -

- This cascades down the stack, as organization instructs implementation, etc. For example, if the architecture has an instruction that names one of N registers as an operand, then the organization has a register file that data flows to and from, and busses to carry that data, the design will specify a register file and layout the busses, and the manufacturing people will build them. -

- -

Where the Turing Machine fits in

- -

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

- -

Computation theoretic consequentiality

- -

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

- -

- When a transform applied to machine m_i produces machine m_{i.1}, and this latter machine gets the same results for the same computational inputs, and furthermore, if any computation theory analysis applied to m_{i.1} yields the same 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

- -

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

- - - m_i(x_{i,j}) = r_{i,j} - - -

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

- - - \begin{aligned} - m_8(x_{8,0}) &= r_{8,0} \\ - m_8(x_{8,1}) &= r_{8,1} \\ - m_8(x_{8,2}) &= r_{8,2} - \end{aligned} - - -

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

- -

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

- - - m_i \xrightarrow{T} m_{i.1} - - -

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

- - - \forall j \colon r_{i,j} = r_{i.1,j} - - -

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

- -

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

- - - \forall i, \forall j \colon r_{i,j} = r_{i.1,j} - - -

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

- -

Definition of the computation theoretic consequential/inconsequential transform property

- -

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

- -

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

- - - a_{i,k} = q_{i,k}(m_i, \{x_{i,j}\}) - - -

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

- -

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

- - - m_i \xrightarrow{T} m_{i.1} - - -

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

- - - \forall k \colon a_{i,k} = a_{i.1,k} - - -

- then T is computation theoretic inconsequential for m_i. -

- -

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

- - - \forall i, \forall k \colon a_{i,k} = a_{i.1,k} - - -

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

- - - - - Symbol - -

- A symbol is a distinct mathematical object capable of being instantiated. Within a given context, any instance of a specific symbol evaluates as equal to any other instance of that identical symbol, and evaluates as not equal to any instance of a different symbol. -

- -

- Put more formally, given a set of instantiable objects and a collection of instances made from them, for these objects to be symbols, two structural conditions must be met. First, it must be possible to define an instance comparison operation, denoted =, that acts as an equivalence relation to partition the collection into discrete equivalence classes. There must be a one to one correspondence between the resulting equivalence classes and the original instantiable objects from which the member instances were derived. -

- -

- It follows from this definition that the distinct equivalence classes can be used as a proxy for the instantiable objects themselves. That is, a person can name either the instantiable object or the equivalence class, and then through this correspondence, find the other. -

- -

The factory interpretation

- -

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

- -

- A symbol instance newly minted by the factory is said to come direct from the factory. A symbol instance direct from the factory is also called an original. -

- -

Required properties of symbol factories

- -

- Any two symbol instances returned directly from two distinct factories will always evaluate to False during an equality comparison. In other words, two distinct originals will always be not equal. -

- -

- 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 any two originals, say A and B, it is established that A is not equal to B, as discussed above. Note also that A is not equal to any copy stemming from B, and B is not equal to any copy stemming from A. -

- -

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

- -

Instance implementation

- -

- Within a process, a reference to the factory can be used as a symbol instance, which will cause the factory to become trivial. Making a new instance will merely require copying the factory reference, and there will be nothing in memory that the base factory reference is pointing to. -

- -

- In general, memory addresses are built in symbol instances, hence within the context of a single process run, a program can make use of these symbols. However, this diminishes the size of the address space and leaves the memory at those addresses unused. A common hedge is then to use references into a dictionary, where the data looked up in the dictionary is the name of the symbol. -

- -

- Such symbol names are non structural strings, so they do not need to follow the rules of symbols. For example, a program written where references to strings were used as symbol instances, could give multiple, or all, strings the same name, and the program would function. Conventionally, the names are made to be distinct so as to avoid confusion. The hazard here is that a programmer will then conflate the string name with the symbol instance, and perform symbol operations with it. -

- -

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

- -

- As another alternative, each factory can be given a base string, and then make returns a copy of the base string. Here we refer literally to the string as the symbol instance. There is no separate name, and the string data, not the reference to the string, becomes the symbol instance. This is however merely an architectural constraint, under the hood an implementation could use string references as long as it always appears to the programmer that the string value is being used. -

- -

- At the time of this writing many machines use 64 bit words. This is equivalent to 8 ASCII characters, while the average size of an identifier is about 5 characters. Hence the approach of using a string as a symbol might not be as inefficient as it seems to be at first. Using strings has advantages. Symbol instances can carry semantic clues for the programmer. There is no hazard of conflating the string instance with the name, as they are the same. Also, a string instance will have integrity across contexts, such as between invocations or when passed between processes (note the section below on crossing context boundaries). A drawback is in cases there is no language support, the strings are typically ad hoc so the guarantee of distinctness becomes merely a contract with the programmer. -

- -

Consequentiality

- -

- The time that a Turing Machine takes to copy a symbol to or from tape is considered to be a single machine step. The step itself is part of the step count, and the count certainly is consequential, but the copy itself is a constant of 1. It will never affect time complexity results. -

- -

- The Turing Machine is defined with a finite alphabet and a couple of additional symbols. As these are part of the machine definition, and thus do not change at run time, the time to make them is inconsequential. -

- -

- On a real machine, the factory would be used to make the alphabet and a couple of additional symbols, but as the alphabet is finite, and set in advance, making it is similarly inconsequential. -

- -

- This leaves the question of the time to copy an instance. Such a copy is done when reading and writing a tape on the Turing Machine, and reading and writing memory on a real machine. As the alphabet is finite, each symbol can be encoded in a fixed number of bits. Hence, a copy time is constant. Typically the number of symbols involved is so small, that a single read or write of memory is required for doing a copy, but even if the number of symbols is enormous, it will be a fixed constant time. There can be extenuating circumstances, such as cache misses and page faults. So generally symbol copy time is inconsequential, but it is possible in address aliasing conditions, say with page faults, can muddy the picture. -

- -

Distinctness across contexts

- -

- If a symbol persists across contexts (such as across scopes or processes), it must remain distinct from all other symbols in its new context. -

- -

- One way to meet this requirement is to find a scope encompassing both contexts and to place the symbol factory there. Another solution is to give each context a distinct root symbol and to use an array of symbols in place of the imported symbol. Yet another approach is to associate an imported symbol with a new symbol in the given new context using a correspondence map. -

- -

- When utilizing memory addresses as symbols in a virtual memory environment, the convention is to disallow addresses in one process from being used in another. If that isolation is insufficient, it is often adequate to use indexes instead of addresses, taking the address to the base of the data structure. Though the absolute address of the data structure might differ across contexts, the relative offset remains constant. Another approach is to reserve memory address blocks and to guarantee imported pages have the exact same addresses as before, though they might be imported sequentially to reuse the memory block. In architecture, this is generally known as the pointer swizzling problem. -

- -

Alphabet

- -

- An alphabet is another name for 'a set of symbols'. Because it is simply a set, an infinite number of distinct alphabets can exist. Papers on Turing Machine typically speak of 'the alphabet', as the alphabet of data symbols. However, other alphabets can be defined for Turing Machines, such as the alphabet of states in the programmed controller. A set of symbols could be finite or infinite. The Turing Machine alphabets are finite. -

- -

Examples

- -

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

- - - /* The enum definition acts as the factory. */ - typedef enum { - SYMBOL_EMPTY = 0, - SYMBOL_ZERO = 1, - SYMBOL_ONE = 2, - SYMBOL_A = 3, - SYMBOL_B = 4 - } TapeAlphabet; - - /* Instantiating copies of the symbols: */ - TapeAlphabet cell_1 = SYMBOL_A; - TapeAlphabet cell_2 = SYMBOL_A; - - /* Equality comparison over instances */ - if(cell_1 == cell_2){ - /* Evaluates to True */ - } - - -

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

- - - - #include <string.h> - #include <stdlib.h> - #include <stdio.h> - - // maximum legal index into the symbol list - #define LIST_EXTENT 3 - - typedef const char *Instance; - typedef struct{ - Instance *head; - Instance *tail; - Instance *extent; - } List; - - static List SYM_LIST = {NULL ,NULL ,NULL}; - - Instance make_list(const char *name){ - size_t size = LIST_EXTENT + 1; - SYM_LIST.head = (Instance *)malloc( size * sizeof(Instance) ); - SYM_LIST.tail = SYM_LIST.head; - SYM_LIST.extent = SYM_LIST.head + LIST_EXTENT; - *SYM_LIST.head = strdup(name); - return *SYM_LIST.head; - } - - Instance make_symbol(const char *name){ - if(!SYM_LIST.head) return make_list(name); - - Instance *pt = SYM_LIST.head; - while(1){ - if( strcmp(*pt ,name) == 0 ) return *pt; - - if(pt == SYM_LIST.extent){ - fprintf(stderr ,"symbol list overflow for %s\n" ,name); - return NULL; - } - - if(pt == SYM_LIST.tail){ - *++SYM_LIST.tail = strdup(name); - return *SYM_LIST.tail; - } - - pt++; - } - } - - int main(){ - Instance a = make_symbol("a"); - Instance b = make_symbol("b"); - Instance c = make_symbol("c"); - Instance d = make_symbol("d"); - Instance e = make_symbol("e"); // overflows table - - Instance *pt = SYM_LIST.head; - Instance *pt_tail = SYM_LIST.tail; - while(1){ - puts(*pt); - if(pt == pt_tail) break; - pt++; - } - - if(e == NULL) printf("e is NULL\n"); - } - - - - The Turing Machine as a computer architecture - -

- In this interpretation of the Turing Machine, the architecture utilizes a single ended tape, as done in Hopcroft and Ullman's book John E. Hopcroft and Jeffrey D. Ullman, Introduction to Automata Theory, Languages, and Computation (Reading: Addison Wesley, 1979).. If a computation requires a two way infinite tape, the single ended tape machine can emulate it 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. When analyzing the time complexity of an algorithm, this overhead merely doubles the constant on the linear term, leaving the asymptotic order of complexity entirely unchanged. The outcomes of decider programs are unaffected. Therefore, utilizing a single ended tape is an inconsequential variation of the two way tape machine. -

- -

- Furthermore, this definition adopts the language of hardware specification rather than formal mathematics. Because this is merely a terminology change with direct correspondences between operations, the resulting model remains isomorphic to the Hopcroft and Ullman definition. Adopting this architectural perspective facilitates the goal of building downward toward a computer architecture, rather than upward to abstract mathematical analysis, though it certainly does not preclude such analysis. In this model, the fixed components are read only, while the memory components will potentially have data flowing through them. As detailed in the control procedures below, data flows dynamically at the command of the programmed controller. -

- -
- Figure 1: A Turing Machine -
Figure 1 A Turing Machine
-
- - -

The Turing Machine consists of:

-
    -
  • a read only alphabet that instances can be made from
    • -
  • a read only empty symbol that instances can be made from
    • -
  • a constant tape consisting of read writable cells
    • -
  • a read only left from leftmost error symbol that instances can be made from
    • -
  • a head bearing tape transport mechanism
    • -
  • a read writable single symbol read data buffer
    • -
  • a constant state machine programmed controller with states that can be referenced
    • -
  • a constant initial state reference
    • -
  • a constant halt state reference
    • -
  • a read writable current state reference variable
    • -
  • a constant operation procedure where each step of the procedure can be referenced
    • -
  • a read writable operation procedure step reference counter
    • -
  • a read only clock to synchronize control and to cause counting until the halt state is reached.
    • -
  • a fixed hardware comparator to evaluate state and symbol equivalencies
    • -
  • a reset button that activates logic that initializes the machine
    • -
- -

Each highlighted term is a short name for the associated item.

- -

- The distinct empty symbol can be any symbol that is excluded from the alphabet. Only instances of alphabet symbols or the empty symbol are permitted to be written to the tape. -

- -

- Intuitively, a person might consider that the alphabet symbols are useful while the empty symbol is merely taking up space while waiting to be displaced, in the same manner that a person considers a bookshelf to be empty rather than being full of air. (And if a person puts a bookshelf underwater, is it still empty, or is it full of water?). -

- -

- Depending on the design, without reset being held during power up, a real machine can land in an illegal state that might not be resettable, and could conceivably be damaging. Hence, reset is normally held during power up, and it is reset, not power up, that causes a machine to land in a known initial state. -

- -

- This design assumes that when reset is released, the then initialized machine starts running. This is fine for our purposes, but surely the deluxe model would have a separate 'go' button and the associated logic. -

- -

- Note that we packaged a tape transport along with the head. In this volume we will talk about sending step commands to the head, but of course a head doesn't step, rather a tape transport mechanism steps. Hence, when we talk about 'stepping the head' implied is that the head remains stationary, and the tape transport mechanism moves the tape. As the tape is normally very long and held on spools, even if we could move the head it would not be very effective. -

- -

- The constant operation procedure should not be conflated with the Turing Machine program. For a microcode controlled machine, the procedure will be found in microcode memory, and it will be executed as though a program. Each line of the procedure, when read, results in a set of bits being connected to the machine's control lines. Some of those control lines will control what the procedure does, and some will extend out into the data path and be used to configure execution units and gate data on to busses. -

- -

- For a hardwired machine, the operation program will be expressed with logic gates and flip flops (single bit memory registers). Whether a machine is microcode controlled, or hardware controlled is a question of implementation. The values on the control lines remain the same independent of those implementation decisions, so those decisions are inconsequential to our architecture discussion. -

- -

- The Turing Machine architecture specifies an infinite tape, which can neither be implemented, nor realized. We will introduce a computationally inconsequential modification in a later chapter that causes the tape to be finite. -

- -

The Turing Machine tape cell

- -

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

- -

- A cell is the square from Alan Turing's 1936 paper Alan M. Turing, "On Computable Numbers, with an Application to the Entscheidungsproblem," Proceedings of the London Mathematical Society s2 42, no. 1 (1936): 230 265.. Mathematically, a cell is a distinct identifiable set, with one to three property members depending on the type of cell. -

- -

- A leftmost cell is a set of two properties named 'right neighbor' and 'data'. A rightmost cell is a set of two properties named 'left neighbor' and 'data'. An interstitial cell is a set holding three properties: a 'left neighbor', a 'right neighbor', and 'data'. While an island cell owns a single compulsory property, that of 'data'. -

- -

- The value of a cell neighbor property is limited to being the identity of a cell. The value of a cell data property can be an instance of an alphabet symbol, or alternatively, an instance of the empty symbol. -

- -

The Turing Machine tape

- -

- The Turing Machine tape is a set containing exactly one leftmost cell and an infinite number of interstitial cells. For each cell in the set, called cell A, if cell A has a right neighbor that is cell B, then cell B's left neighbor is cell A. Similarly, if cell A has a left neighbor of cell B, then cell B's right neighbor is cell A. Furthermore, any cell in the set must be reachable by traversing right neighbors starting from the leftmost cell, in a finite number of steps. -

- -

- To say that a tape is infinite, and to simultaneously require that any cell can be reached in a finite number of steps, might seem to be contradictory. However, these locutions are compatible in their meaning. By saying the tape is infinite, we are saying that after reaching a cell through a finite number of right neighbor hops, there will always be further cells to the right. So though any cell can be reached in finite hops starting at the leftmost cell, all of the cells cannot be reached. -

- -

- In conventional computation theory, once a tape is defined the cell neighbor properties values are fixed. Cells don't move, new cells cannot be added, and cells existing on the tape cannot be removed. This fits the definition of a space, so we can say that a Turing Machine tape has a constant, fixed, linear topology. This also matches the reality of hardware memories. On the other hand, it does not track well with general memory containers such as linked lists where destructive operations are often permitted. -

- -

- Nor can a cell data property be removed; however, unlike for cell neighbor property values, the cell data property value can be changed while the Turing Machine is running. In fact some people would say this is the whole point of running a Turing Machine. -

- -

- Initially the Turing Machine tape is filled with empty symbols. However, as we noted above, a Turing Machine cannot visit all the cells on a tape, so a Turing Machine cannot erase a tape in advance for another Turing Machine to use. In a later chapter we will provide a computationally inconsequential alternative, but for now we will do as all have done before us, and decree that initial empty tapes are available by definition. -

- -

- The tape is intentionally defined in such a manner that there is no meaning to 'in between' two cells. The head of the machine is always on exactly one cell, with the option of stepping to neighbor cells. Taking a step is an atomic operation; there is no meaning to 'during the step'. Turing Machines are state machines controlled by a clock. A person only asks questions of them when the machine is in a defined state. -

- -

- Mathematically, a Turing Machine tape can be expressed as a path graph. However, a tape model and a path graph model imply different ontological contexts. The neighbor property of a Turing Machine tape cell specifically informs a clock driven atomic step function where to place the machine head next. The machine only has defined meaning at the state points on the programmed controller. In contrast, a path graph exists in the wider context of graph theory. A path graph has edges and each edge can be focused on, said to be traversed over, and given general properties. These are things we explicitly excluded in the tape definition. If we were to move the tape from the context of the machine and into the more abstract mathematical context by modeling the tape with a path graph, then we would do so for the purpose of analyzing the tape, which is a higher order and more abstract activity. However, in the current exercise we are not reaching towards the more abstract; rather, we are reaching in the other direction, towards machine architecture. -

- -

The Turing Machine tape head

- -

- The tape head consists of a reference to exactly one of the tape cells and a set of four functions: read, write, step-left, and step-right. In addition, the tape head can throw an error, left-of-leftmost, if the Turing Machine attempts to step left from the leftmost cell. When stepping, the cell reference in the head is updated based on the neighbor properties of the currently referenced cell. The cell referenced by the head is called the cell the head is on, or more simply, the head cell, or more generally as the indicated cell. -

- -

- A person can also say that the head indexes the head cell. This utilizes the classical mechanical definition, where an index is a mark for aligning gears. This physical meaning contrasts with an index integer used for addressing an array. The architectural definition of the Turing Machine developed here relies strictly upon the topological properties of the tape, independent of the definition of Natural Numbers. Addresses, which do rely on Natural Numbers, are discussed further on in this volume. This represents a minor divergence from Alan Turing's original paper, as he took it as a given that numbers naturally paired with the squares. We explicitly establish that pairing only after deriving Natural Numbers using the Turing Machine itself. -

- -

The programmed controller

- -

- There are two distinct centers of logical control for the Turing Machine. The one we are most familiar with from the many descriptions of the Turing Machine in papers is called the 'state controller'; however, this term becomes confusing when we realize there are additional controllers involved. Hence, we call this component the programmed controller. It is customized for each different problem the Turing Machine will work on, while the other controllers give the Turing Machine its fixed characteristics. -

- -

Components

- -

The programmed controller contains the following components:

-
    -
  • alphabet of states
    • -
  • a reset control line
    • -
  • a step control line
    • -
  • an initial state
    • -
  • a halt state
    • -
  • a current state register
    • -
  • a comparator
    • -
  • an instruction table
    • -
  • a next state table
    • -
  • default next state table
    • -
  • error state symbol
    • -
- -

- Each state corresponds to a symbol. Here, instances of the state symbols appear in a different context than that of the data alphabet symbols or the empty symbol, and thus they do not need to be distinct from them. In real machines, state symbol instances are unsigned integers. -

- -

- The alphabet of states is specified in the architecture, and in the design stage becomes a table in a document where each row relates a bit vector with a name. It remains a documented abstraction to the designers, but can become embodied in programs where meaningful print statements are needed. Perhaps in a CAD tool such as a hardware debugger. -

- -

- The current state register holds an instance of the current state symbol. During reset its value is forced to be an instance of the initial state symbol. During normal operation it is successively updated with the prior next state choice. -

- -

- The current state register output is wired to the comparator, along with the halt symbol. A positive match across the comparator asserts a gating signal that halts the machine clock. This halts the internal procedures (discussed in a later chapter), which guarantees that no further step pulses will arrive at the programmed controller. -

- -

- The current state register is used to lookup a row in the instruction table. Each defined row contains an instruction that is sent to the tape transport unit. A retrieved instruction provides the specific control code and, in the case of a write instruction, the argument symbol to be written. If the current state yields no match in the instruction table, the logic defaults to issuing a 'no-op', no operation instruction. While a 'no-op' need not be physically acted upon by the tape transport, the fixed wiring typically propagates the signal regardless. -

- -

- The current state register, concatenated with the output of the read buffer, is used to lookup a row in the next state table. It yields the subsequent state, or an indication that the given input is not found. -

- -

- The current state register is also used to lookup a row in the default next state table while ignoring the read buffer output. An entry for a given state might not exist here either. -

- -

- The 'lookup' operation can be implemented in a number of ways, at the election of the design engineers. In the simplest form a lookup indexes into an array, though this can be inefficient. For such small machines a hash table is an unlikely alternative. More likely is content addressable memory, a programmable logic array, or custom combinational logic. -

- -

- The programmer must provide the state alphabet, the instruction table, and the next state table. To do this, the programmer benefits from understanding how the programmed controller works. When preparing to provide the tables, the programmer can draw a state machine graph. There are two styles of state machine graphs: the Mealy style and the Moore style. The Mealy style has outputs specified on the edges, while the Moore machine has outputs associated with states. They are equivalently expressive, though the Moore style more easily leads to the table values for the programmed controller described in this section. -

- -

- Each defined row of the instruction table specifies a state specific instruction to be given to the tape transport unit. The instruction will be one from the set: { no-op, step-left, step-right, and write(value) }, where the value parameter for a write instruction is coded directly as part of the instruction. -

- -

Control logic

- -

- The following procedure is embodied as further control logic in the Turing Machine. This procedure is fired upon receiving a step pulse. At the time the procedure is entered, the head is stable upon a cell. We list phases so as to avoid any apparent race conditions. This does not dictate to the designers that the clock must have phases, though that isn't excluded either. -

- -

Deterministic (Uniplex) programmed control procedure

- -

Upon each step pulse:

- -

Phase 1:

-
    -
  1. read the symbol instance indicated by the head into the read data buffer
    2. -
- -

Phase 2:

-
    -
  1. lookup the current state in the instruction table
    2. -
  2. lookup the current state concatenated with the read data buffer in the next state table
    3. -
  3. lookup the current state in the default next state table
    4. -
- -

Phase 3:

-
    -
  1. if the current state is found in the next state table, use the retrieved value as the next state. Otherwise, if the current state is found in the default next state table, use the default state as the next state. Otherwise, use the error state as the next state.
    2. -
  2. if an instruction was retrieved from the instruction table, the tape transport executes it. Otherwise, the tape transport executes the default 'no-op' instruction.
    3. -
- -

Phase 4:

-
    -
  1. write the next state to the current state register
    2. -
  2. controller remains quiescent waiting for the next step pulse
    3. -
- - -

Consequentiality of architectural level control

- -

- In common books and papers about the Turing Machine, a step is defined as one step of the programmed controller, i.e. one pass through the four phase procedure given above. Decider proofs ask if the comparator will match the halt state within a finite number of steps. Time complexity proofs take a formulation of step count to reach the halt state, parameterized against the size of the input, and report the order of the highest term as it is asymptotically dominant. Hence we speak of constant, linear, polynomial, and exponential time complexity algorithms. A similar method of analysis, that of memory usage with step count, parameterized against input size, is used for space complexity. -

- -

- For a real machine, the step pulse will be derived from the machine clock. The clock will have a constant period, so there is a constant duration of time that will be the same for each pass through the execution procedure. Thus, if we replace the step count with a count of clock ticks, we will get the same decider and complexity results as we would have from step counts. This fits the definition we have been using for inconsequential. -

- - -

An alternative: stored program and sequencer

- -

- The Universal Turing Machine, proposed by Alan Turing, introduced a profound architectural inversion: relocating the defining state tables from hardwired logic, or manually configured patch panels, directly onto the tape itself. This enables replacing the custom programmed controller with a fixed controller that derives its behavior dynamically from the tape data. Consequently, a single, immutable hardware architecture can simulate the execution of any conceivable Turing Machine. -

- -

- In addition, encoding a machine's control logic as parseable data on tape establishes an ontology of analysis, a framework where a machine can analyze another machine to establish some properties the other machine might have. We say 'some' because at least one limitation has been proven. Alan Turing proved that such an analyst cannot in general determine if said other machine has the property that it would halt for any input when run. -

- -

- We can optimize this representation. Instead of storing the state tables verbatim, we can list a sequence of instructions directly on the tape. To achieve this, the architecture expands to support two distinct categories of instructions: the physical tape transport instructions we defined previously, and a newly introduced category of control instructions. The programmed controller is then replaced with a fixed hardware controller called a sequencer. -

- -

- Because the original state tables allowed for non linear execution paths, the instruction sequence on the tape cannot always execute in a straight line. Therefore, the architect must include at least two control instructions: a halt instruction and a test and branch instruction. The sequencer starts at the first instruction in the program, perhaps at the leftmost cell on the tape, and evaluates it. If it is a control instruction, the sequencer acts upon it directly to alter the flow of execution or stop the machine. Otherwise, if it is a physical instruction for the head unit, the sequencer passes it down to the tape transport. -

- -

- Because we have not yet derived Natural Numbers or memory addresses in this architecture, a test and branch instruction cannot jump to a numerical address. Instead, it must operate topologically. A topological branch instruction simply commands the sequencer to scan the tape for a specific target symbol, and resume executing instructions from that physical location. -

- -

- As noted in the prior section, an instruction consists of an instruction code and potentially an argument. There are many choices that can be made in instruction set design. Among those choices, almost all will be inconsequential from a computation theoretic point of view, but almost all will introduce strict efficiency trade offs in physical hardware. -

- -

Machine control

- -

- In the prior two sections we discussed the configurable part of the Turing Machine control. Here we complete the picture by describing the fixed portion. -

- -

Setup

-
    -
  1. select and mount a tape
    2. -
  2. push the reset button
    3. -
- -

Reset

-
    -
  1. step the head left until an 'left of leftmost' error from the tape transport unit, the head will then be on the leftmost cell
    2. -
  2. hit reset on the programmed controller, or the sequencer, depending on which is being used
    3. -
  3. wait until the release of the reset button
    4. -
- -

Main:

-
    -
  1. evaluate the value of the reset line coming from the reset button
    2. -
  2. if the reset line is true, execute the Reset procedure
    3. -
  3. if the reset line is false, evaluate the halt line coming from the comparator
    4. -
  4. if the halt line is true, freeze execution until reset is asserted, then return to step 1
    5. -
  5. if the halt line is false, send a step pulse to the programmed controller (or sequencer) on each clock tick
    6. -
- -

- A person can read this procedure with the caveat, "if we could realize such a machine, this is what we would do." Later, these directions can be modified and applied to the machine variation that has an expanding tape. -

- -

- To start the machine we must first select a tape. Common choices are an empty tape, a tape with data on it the machine is to decide matches a given language pattern, or a tape with a Turing Machine on it to be analyzed. After the tape is selected it is mounted on the Turing Machine, then the reset button is hit. -

- -

- After the reset button is released, the machine begins stepping. If the program is a computation, the machine will eventually halt. If the machine eventually halts, then we know the associated program was a computation. Otherwise we do not know. Any amount of time we wait where the machine has not halted, we will not know that it will ever halt. Hence, we cannot in general use 'running a Turing Machine' as a means to determine if a given program is computational. (We could instead try to answer the question 'is it computational' through analysis, but there too, Turing has shown that in general that will not work either.) -

- - - Area and partitions - -

- We call a subset of contiguous cells from a tape an area of said tape. An area with a single cell is called a singleton, one with two cells is called a pair. An area has a leftmost cell and a right most cell, for a singleton area, those will both be the same cell. Unless the area is sitting on the end of the tape, it will have a left neighbor cell. A finite area will have a right neighbor cell. An area can be open on the right. -

- -

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. An area can also be partitioned, which leads to nested areas. -

- -

Head partition

- -
    -
  1. The left side: a potentially empty finite set containing all of the cells to the left of the head cell.
    2. -
  2. Head: the head cell.
    3. -
  3. The right side: the infinite set extending rightward from the right neighbor of the head cell.
    4. -
- -

Leftmost/remaining partition

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

Active area partition

- -

- A nonempty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: -

- -
    -
  1. The left empty tail: this area is empty when the leftmost cell is nonempty. Otherwise, it consists of the leftmost cell and the empty cells, if any, to the right of the leftmost cell, up to the first alphabet cell.
    2. - -
  2. Active area: a finite area for computational problems, containing the cells extending from the leftmost alphabet cell up to and including the rightmost alphabet cell. It is possible that the leftmost alphabet cell and the rightmost alphabet cell will be the exact same cell.
    3. - -
  3. The right empty tail: the infinite set extending from the right neighbor of the rightmost cell of the active area, extending rightward.
    4. -
- -

Area implied partition

- -

- Given any area on a tape, or nested within another area, the potential for two additional areas is implied. -

- -
    -
  1. The left side: a potentially empty finite set containing all of the cells to the left of the given area.
    2. -
  2. The given area.
    3. -
  3. The right side: for a tape, the infinite set extending rightward from the rightmost cell of the given area. For a nested area, this could be empty or finite.
    4. -
- - -

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

- -

- The active area partition of a tape only works for tapes that have at least one alphabet cell. As soon as a machine does its first write of an alphabet symbol, it is known the tape has at least one alphabet symbol. However, what if a tape of unknown status, whether completely empty or containing an alphabet cell, is mounted on a tape machine, and it is desired that the machine recognize if the tape is empty or has an alphabet cell? This is the equivalent problem of looking for the leftmost cell of an active area. -

- -

- Recognizing that a tape is empty is generally impossible. Suppose it were attempted, and a machine started scanning the tape rightward from the leftmost cell; for every cell that is discovered to be empty, the machine would have to scan further rightward to check for an alphabet cell. If the tape is truly empty, the recognizer would never stop scanning, so no decision would ever be rendered. -

- -

The impossibility of recognizing the rightmost cell of the active area

- -

- In general, a Turing Machine cannot step across a tape reading cells to recognize the rightmost cell of the active area, or equivalently, the leftmost cell of the right empty tail. Suppose a recognizer attempted this by starting in the active area and stepping right, and the machine discovered an empty cell. The machine would be unable to distinguish between the case of said empty cell being embedded within the active area (meaning more alphabet cells lie further to the right), or the case where said cell is genuinely the leftmost cell of the right tail. To resolve the ambiguity, the machine would be obligated to continue stepping right. Yet, there would never come a time where finding another empty cell would avoid leading back to the exact same case ambiguity, so the machine would forever step right without returning a decision. -

- -

- It follows that if knowledge of the end of the active area is needed, this information must be encoded as a message. For example, a special symbol can be reserved in the alphabet specifically to serve as the end of active area marker. Each time a machine steps beyond the current end of active area marker and does a write, it writes the marker in the right neighbor cell, and goes back and erases the old mark. This method is related to communications theory and the science of signaling. Here, the active area marker is an out of band control signal. -

- -

- If a tape is written by an initializing tape machine, unmounted, and then mounted on a second analyzing tape machine, the analyzing tape machine is starting with a populated tape. Similarly, a mathematician can, by decree, define an initial tape that holds predefined alphabet symbols. In these cases, the analyzing machine cannot use the signaling method described in the prior paragraph, as it was excluded from controlling all the writes of alphabet symbols to the tape. The only solution to this problem is for the initializing machine and the analyzing machine to use a shared communication protocol for signaling the end of the active area. -

- -

- By definition, a computation must finish in a finite number of steps. It follows that the active area when a Turing Machine halts a computation will always be finite. Consequently, if a Turing Machine initially starts working with a tape that was computed by another Turing Machine, the length of the input will be finite. Still, that input will be in the active area, so the receiving Turing Machine will need to read control data left on the tape under a common communication protocol to be able to find the bounds of the input area. -

- -

- When an input tape is provided as a general mathematical object, either decreed by definition or perhaps abstracted from 'what a Turing Machine computation would produce in the limit of step count', then the input can be either finite or infinite. -

- -

In band and out of band control

- -

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

- -

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

- -

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

- -

Abstract areas and partitions

- -

- A tape area and partitioning can be an abstraction defined by a function rather than merely by a leftmost and rightmost cell. Such areas can have different topologies than those of the base tape. A familiar example for most computer scientists is utilizing software to create the appearance of a two dimensional array over a linear memory. -

- -

- Accordingly, suppose there is a three tape Universal Turing Machine gasket machine that holds the definition of a base machine on a first tape. It calls the base machine as a subroutine to access the base machine's tape (the second tape), and it uses its own tape to organize the tape abstraction. Then this outer machine can present to its user a variety of transforms of the base machine's tape. -

- -

- As an example, a gasket machine could partition the base machine's tape into two areas, one consisting of the odd addressed cells, and the other of the even addressed cells. Though these two areas consist of noncontiguous cells on the base tape, when viewed through the gasket machine, they appear perfectly contiguous. In this case, each area will have a leftmost cell and remain open on the right. -

- -

- When the base machine tape cells behind an abstract area are physically contiguous, we say that the abstract area is compact. In the odd even tape partition example, the abstract areas lack compactness. -

- - - Addresses - -

We can define a Turing Machine that is identical to the recursive definition of Natural Numbers as given by Peano. Giuseppe Peano, Arithmetices principia, nova methodo exposita (Turin: Fratres Bocca, 1889).

- -

If we were to run the Natural Numbers Machine and watch as it writes to the tape, we would watch as the Natural Numbers are printed one after another, '·s·ss·sss·ssss· ...'. Here we are using the middle dot as a terminator symbol. As the Natural Numbers Machine never halts, we cannot use the Natural Number Machine to initialize a tape, but we can analyze the machine. When the leftmost cell holds a terminator, we say it has the value 'zero'. We call '·s·' the number 'one'. Each set of 's' adjacent symbols surrounded by the terminators, and zero, is said to be a Natural Number. -

- -

To say that one Natural Number A is smaller than Natural Number B is to say that A would occur on the Natural Number Machine tape to the left of B, if the machine were to be run. Similarly, if B were said to be greater than A, that would mean B would occur further to the right. To increment a Natural Number is to find its right neighbor. To decrement a number is to find its left neighbor. -

- -

- Now suppose we have a single Natural Number on a tape, say 'sss·', then we can define an Increment machine that, when initialized with a tape, writes an additional 's' and a new terminator. For example, when initialized with 'sss·' and then run, it produces 'ssss·'. In an analogous manner, we can define a Decrement machine. -

- -

As such, we can assign a Natural Number to each member of the tape sequence through the following procedure. Given a machine, say P, we lock to it a second Address Machine, say A_P. When P's tape is first mounted, at the same time A_P is mounted with a tape that has only a terminator symbol, '·'. When P steps right, A_P writes an 's', steps right, and writes the terminator. For each step left of P, the machine A_P steps left and writes the terminator symbol. -

- -

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

- -

- An address space is the set of addresses that would be placed into correspondence to cells if we were to step across all those cells while assigning an address to each cell the head is on. Address space is a second order concept. It is because assigning an address to a cell can be a second order concept that we often take it for granted. -

- -

- It is interesting to contemplate if the Natural Number at the basis of the Address Machine instead used Arabic Representation. In that case, an increment or decrement would be a linear time operation due to the carry. Consider a constant time operation on the base machine P, say it steps to the right 5280 cells and writes a mile marker. It would still be a constant time operation no matter the time taken for the address increment. So then consider an operation that is linear time, say a n, where n is the length of the input. Say, for example, it stepped n cells to the right and wrote a marker. If the increment time grows linearly with each step, then what was time n without addresses becomes time n^2 with them, or polynomial time. So indeed using Arabic Representation instead of unary for the address would be computationally consequential for all but constant time machines, if addresses were kept track of in the first order. -

- -

- As of the time of this writing, real machines keep the illusion of constant time Arabic Representation for addresses due to fixed width clocked operations. When the width is fixed, and that fixed number is small enough that interconnect delay does not dominate over computation element delay, adder time tends to be logarithmic. The same is true of the related problem of address decoding. Thus an add can be performed within 'one clock tick'. Native address arithmetic operations on modern machines are always done in this manner. Perhaps there exists a special problem, such as pointer swizzling, where address arithmetic would come under software control. -

- -

- The model used here to define an address is analogous to keeping a pointer into memory, and then using that pointer value as the address. Each step then increments or decrements the pointer. On a real machine, to access memory requires sending that pointer on a trip through a virtual memory system perhaps, and then through an address decoder. In the Turing Machine model, the head directly indicates a location, so it is more akin to the output of the memory decoder, though unlike the output of a memory decoder, it is stateful, i.e., a persistent value that can be moved incrementally. The analogy with the Turing Machine model holds due to the fiction of a constant decode time, as described in the prior paragraph. -

- -

- At a higher level, that virtual memory system level, the memory architecture begins to look more like that of a Turing Machine. The translation lookaside buffer provides stateful location context, and the neighbor relationship between pages might be taken into account for performance reasons. However, once a program starts performing at virtual memory page fetch times instead of local system memory access times, we say that it is page thrashing and know it will become too slow to wait on, no matter its computation complexity class. -

- -

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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Memory TierReal World LatencyScaled DelayScaled Arrival EraHistorical Context
L1 Cache Hit1 ns3 days0043 03 18 BCThree days after the assassination.
DRAM (Main memory)100 ns300 days0042 01 09 BCNearly a year later, during the Liberators civil war.
NVMe SSD Page Swap15 µs45,000 days0080123 years later, exactly as the Colosseum is completed in Rome.
SATA SSD Page Swap100 µs300,000 days0778821 years later, during the reign of Charlemagne and the Frankish Empire.
Magnetic HDD Page Swap10 ms30,000,000 days82092Tens of thousands of years in the future, long after current human civilizations are dust.
- -

This is why computer architects spend almost all of their effort designing memory subsystems that have a high statistical chance of executing in the lower levels of the memory abstraction stack. There is not a single chapter on computation theory in Hennessy and Patterson's Computer Architecture: A Quantitative Approach, for example. John L. Hennessy and David A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed. (Cambridge: Morgan Kaufmann, 2017).

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Chapter 1Fundamentals of Quantitative Design and Analysis
Chapter 2Memory Hierarchy Design
Chapter 3Instruction Level Parallelism and Its Exploitation
Chapter 4Data Level Parallelism in Vector, SIMD, and GPU Architectures
Chapter 5Thread Level Parallelism
Chapter 6Warehouse Scale Computers
Chapter 7Domain Specific Architectures
Chapter 8The Future of Computing
- - Address defined area, distance, extent, length, and size - -

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

- -

- When cells were defined we noted that they were sets, and that these sets had identity and could be referred to. We needed that to be the case so as to build the tape topology using neighbor properties. Had the tape been singly linked, perhaps we could have used the cells to represent themselves in the properties, but when we doubly linked it, a given cell had to appear in two places, as the right neighbor of its left neighbor, and the left neighbor of its right neighbor, so we stipulated the sets as being identifiable. Initially we did not say how they would be identified. This is common in mathematics, but we soon cleared this up by formalizing the concept of a symbol. -

- -

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

- -

- So we now have two means for identifying a feature. One means is to state its address, and the other is to put a tape machine head on it. -

- -

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

- -

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

- -

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

- -

In an analogous manner to defining an address space for a tape, we can define an address space for an area. Accordingly, the leftmost cell of the area is assigned address zero, and the address increments cell by cell going to the right. A finite area will have a finite address space, with the address of the rightmost cell being the largest address in the address space. -

- -

It is interesting that the extent of an area will be the same, whether it is calculated from the address space of the tape, or the address space of the area. When it is computed from the address space of the area, the extent will be identical to the largest address in the address space. We will use the Greek symbol omega, ω, to symbolize an extent. We can give it a subscript with the name of an area if the correspondence is not already clear. I chose ω because ω is the rightmost letter included in the Greek alphabet. Thus it is the extent of the Greek alphabet. -

- -

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

- -

The count of cells in an area, the length of an area, and the cardinality of the address space for an area are all the same number, ϡ. The extent of an area, ω, is an address in an area's address space, whereas the cardinality of an area, ϡ, falls completely outside it. This has implications. Because extent is an address, extent and addresses can always use the same number representation. In contrast, there is no such guarantee for cardinality, ϡ. Take for example an area that contains 256 cells. The addresses run from zero to 255, and all can be represented with an 8 bit binary number. However, the number 256 does not fit. It is for this reason that it might make more sense to use extents than to use lengths. -

- -

It is considered by some to be profound that the cardinality of a bounded set of Natural Numbers is excluded from the set. If we generalize to an area that is open on the right, for the cardinality of the address space to fall outside the address space would mean that the cardinality of Natural Numbers falls outside the Natural Numbers. It seems peculiar that cardinality, which is a count, is found to fall outside the numbers we use for counting. Though at this point we are asking for an outer bounding value on an infinite set. -

- -

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

- -

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

- -

How cardinality is computed

- -
    -
  1. We set Turing Machine P with its head on the leftmost cell of an area. We mount the initial tape, '·', on the A machine.
    2. -
  2. We step P and simultaneously run the A machine. Stepping stops when P reaches the rightmost cell of the area. At this point, the tape on the A machine holds the address space extent.
    3. -
  3. The A machine is run an additional time. The output on the tape is defined to be the cardinality of the address space, aka the cardinality.
    4. -
- -

Lemma 1, the A machine produces Natural Numbers

- -

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

- -

Lemma 2, cardinality is a natural number

- -

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

- -

Lemma 3, cardinality is not in the address space

- -

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

- -

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

- -

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

- -

The apparent contradiction.

- -

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

- -

Resolution

- -

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, 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 ℵ_0. -

- -

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 ℵ_{−1}. -

- -

- Now here is an interesting result: -

- - - ℵ_{0} − ℵ_{−1} = 1 - - -

- Neither machine can be run. However we can compose the two machines, then simplify the composition. When we do so, the ever larger Natural Number machines annihilate each other, and the increment machine remains. The increment machine can be run, so we end up with an output value. -

- -

Size

- -

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

diff --git a/document/temp2.html b/document/temp2.html deleted file mode 100644 index f419aff..0000000 --- a/document/temp2.html +++ /dev/null @@ -1,457 +0,0 @@ - Area and partitions - -

- We call a subset of contiguous cells from a tape an area of said tape. A finite area of at least three cells will have a left most cell in the area, a right most cell in the area, with one or more interstitial cells. A leftmost cell in an area might have a left neighbor property, but the cell indicated by that property is not in the area. Or it is possible that the leftmost cell of an area is also the leftmost cell of the tape, and thus it does not have a left neighbor property. Any cell on a single ended tape will have a right neighbor property, but for a a finite area the rightmost cell's right neighbor property will indicate a cell that is not in the area. It is possible for an area to be open on the right, and thus not be finite. - In this manner we distinguish between tape cell types, and area cell types. -

- -

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. An area can also be partitioned, which would lead to nested areas. -

- -

Head partition

- -
    -
  1. The left side: a potentially empty finite set containing all of the cells to the left of the head cell.
    2. -
  2. Head: the head cell.
    3. -
  3. The right side: the infinite set extending rightward from the right neighbor of the head cell.
    4. -
- -

Leftmost/remaining partition

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

Active area partition

- -

- A non empty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: -

- -
    -
  1. The left empty tail: this area is empty when the leftmost cell is not empty. Otherwise, it consists of the leftmost cell and the empty cells, if any, to the right of the leftmost cell, up to the first alphabet cell.
    2. - -
  2. Active area: a finite area for computational problems, containing the cells extending from the leftmost alphabet cell up to and including the rightmost alphabet cell. It is possible that the leftmost alphabet cell and the rightmost alphabet cell will be the same cell.
    3. - -
  3. The right empty tail: The infinite set extending from the right neighbor of the rightmost cell of the active area, extending rightward.
    4. -
- -

Area implied partition

- -

- Given any area on a tape, or nested within another area, there is implied the potential for two more areas. -

- -
    -
  1. The left side: a potentially empty finite set containing all of the cells to the left of the given area.
    2. -
  2. The given area.
    3. -
  3. The right side: for a tape, the infinite set extending rightward from the rightmost of the given area. For a nested area, this could be empty or finite.
    4. -
- - -

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

- -

- The active area partition of a tape only works for tapes that have at least one alphabet cell. As soon as a machine does its first write of an alphabet symbol, it is known the tape has at least one alphabet symbol. However, what if a tape of unknown status, whether completely empty or containing an alphabet cell, is mounted on a tape machine, and it is desired that the machine recognize if the tape is empty or has an alphabet cell? This is the equivalent problem of looking for the leftmost cell of an active area. -

- -

- Recognizing that a tape is empty is not generally possible. Suppose it were attempted, and a machine started scanning the tape rightward from the leftmost cell; for every cell that is discovered to be empty, the machine would have to scan further rightward to check for an alphabet cell. If the tape is truly empty, the recognizer would never stop scanning, so no decision would be rendered. -

- -

The impossibility of recognizing the rightmost cell of the active area

- -

- In general, a Turing Machine cannot step across a tape reading cells to recognize the rightmost cell of the active area, or equivalently, the leftmost cell of the right empty tail. Suppose a recognizer attempted this by starting in the active area and stepping right, and the machine discovered an empty cell. The machine would not be able to distinguish between the case of said empty cell being embedded within the active area (meaning more alphabet cells lie further to the right), or the case where said cell is genuinely the leftmost cell of the right tail. To resolve the ambiguity, the machine would be obligated to continue stepping right. Yet, there would never come a time where finding another empty cell would not lead back to the exact same case ambiguity, so the machine would forever step right without returning a decision. -

- -

- It follows that if knowledge of the end of the active area is needed, this information must be encoded as a message. For example, a special symbol can be reserved in the alphabet specifically to serve as the end of active area marker. Each time a machine steps beyond the current end of active area marker and does a write, it writes the marker in the right neighbor cell, and goes back and erases the old mark. This method is related to communications theory and the science of signaling. Here, the active area marker is an out of band control signal. -

- -

- If a tape is written by an initializing tape machine, unmounted, and then mounted on a second analyzing tape machine, the analyzing tape machine is not starting with an empty tape. Similarly, a mathematician can, by decree, define an initial tape that is not empty. In these cases, the analyzing machine cannot use the signaling method described in the prior paragraph, as it was not in control of all the writes of alphabet symbols to the tape. The only solution to this problem is for the initializing machine and the analyzing machine to use a shared communication protocol for signaling the end of the active area. -

- -

- By definition, a computation must finish in a finite number of steps. It follows that the active area when a Turing Machine halts a computation will always be finite. Consequently, if a Turing Machine initially starts working with a tape that was computed by another Turing Machine, the length of the input will be finite. Still, that input will be in the active area, so the receiving Turing Machine will need to read control data left on the tape under a common communication protocol to be able to find the bounds of the input area. -

- -

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

- -

Abstract areas

- -

The concept of area can be abstracted to include a set of cells that share a property.

- -

This might be a property of the values in the cells, or a property of the addresses of cells.

- -

An abstract area can be colored by a property detecting machine.

- -

Such a machine would start at the leftmost cell, check the value in that cell for the given property and mark it accordingly. It would then step right and repeat.

- -

For such a marker machine to be computational there will have to be a leftmost cell in the area, and upon finding a leftmost cell in the area, a rightmost cell will have to exist. Without both of these boundaries, a marker machine will never halt.

- -

Even if a marker machine does not halt, it still might be useful for analysis.

- -

Marker machines that color based only on the value found in each individual cell are context free.

- -

Abstract areas can also be defined based on functions of cell values that include context.

- -

When the cells in an abstract area are contiguous, we say that the area is compact.

- -

An example of an area that is excluded from being compact is that of the odd addressed cells.

- -

The odd and even addressed cells of a tape form two non overlapping abstract areas.

- -

Given a cell in either of these abstract areas, its direct physical neighbors on the tape will be found in the opposing area.

- - -

In band and out of band control

- -

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

- -

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

- - - Computational Analysis - -

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

- -

- In computation theory, computational analysis is defined as the static evaluation of a formal system or machine definition to deduce its absolute boundaries and properties. This process remains entirely distinct from dynamically executing the machine to yield a computed result. -

- -

- This analytical perspective has been present from the very beginning of the field. Alan Turing's formulation of the halting problem relies explicitly on one machine examining another. To properly evaluate the limits of this analytical capacity, the examining machine must necessarily be given definitions of programs that loop infinitely. Consequently, the foundational proofs of computer science formally establish non computational programs as legitimate objects of analytical study. -

- -

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

- -

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

- -

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

- -

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

- -

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

- -

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

- -

- As an analyzer does not run the machine being studied, 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. -

- - Computational Naturalism - -

- Given that we have an architectural definition for a Turing Machine, and will modify this in a later chapter to define a realizable Turing Complete architecture, it is possible to invert the foundation of mathematics. Instead of mathematics preceding computation, we posit that given a Turing Machine exists, all of mathematics is an interpretation of what can be done with it. -

- -

- We begin by defining the tape cell as a location in a physical memory, which provides us with arrays of charge configurations. -

- -

- We then define the symbol in computational terms, as done in the prior section. This begins with memory addresses, represented as charge arrays, acting as primitive symbols, and extends to the symbol factory, copy operations, and instance comparison. -

- -

- Logic is then defined on top of relay switch logic, as Shannon and others have already done. A machine that requires all inputs to be the '1' symbol to produce a '1' symbol output is a conjunction machine, and so forth. -

- -

- On top of this we can define the Peano Machine, a counter, and then use that machine as the definition of Natural Numbers. -

- -

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

- -

- An axiomatic proof is then a decider that is built up from subroutine calls to the axioms. We might then quantify over all possible compositions of our subroutines in analysis and ask if it is possible that a contradiction decider would return Y or N. -

- -

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

- -

- With the language of Computational Naturalism it is possible to restate every statement ever made by any mathematician; we might say that the mere fact that a mathematician was able to state something qualifies its membership into Zermelo's S set. -

- -

- Given our knowledge that a universal halting problem analyzer that decides if a Turing Machine program halts does not exist, it is desirable to have rules that guide our writing only Turing Machine programs that are known to halt. This can be done through construction, as proposed by Russell, or through axioms of separation, mapping, and choice, as proposed by Zermelo and others. But then we know from the completeness and correctness theorems, that when such guiding rules are applied, there will exist Turing Machine programs that do halt, but whose definition cannot be constructed, nor surmised using the said axioms. -

- -

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

- - Addresses - -

We can define a Turing Machine that is identical to the recursive definition of Natural Numbers as given by Peano. Giuseppe Peano, Arithmetices principia, nova methodo exposita (Turin: Fratres Bocca, 1889).

- -

If we were to run the Natural Numbers Machine and watch as it writes to the tape, we would watch as the Natural Numbers are printed one after another, '·s·ss·sss·ssss· ...'. Here we are using the middle dot as a terminator symbol. As the Natural Numbers Machine never halts, we cannot use the Natural Number Machine to initialize a tape, but we can analyze the machine. When the leftmost cell holds a terminator, we say it has the value 'zero'. We call '·s·' the number 'one'. Each set of 's' adjacent symbols surrounded by the terminators, and zero, is said to be a Natural Number. -

- -

To say that one Natural Number A is smaller than Natural Number B is to say that A would occur on the Natural Number Machine tape to the left of B, if the machine were to be run. Similarly, if B were said to be greater than A, that would mean B would occur further to the right. To increment a Natural Number is to find its right neighbor. To decrement a number is to find its left neighbor. -

- -

- Now suppose we have a single Natural Number on a tape, say 'sss·', then we can define an Increment machine that, when initialized with a tape, writes an additional 's' and a new terminator. For example, when initialized with 'sss·' and then run, it produces 'ssss·'. In an analogous manner, we can define a Decrement machine. -

- -

As such, we can assign a Natural Number to each member of the tape sequence through the following procedure. Given a machine, say P, we lock to it a second Address Machine, say A_P. When P's tape is first mounted, at the same time A_P is mounted with a tape that has only a terminator symbol, '·'. When P steps right, A_P writes an 's', steps right, and writes the terminator. For each step left of P, the machine A_P steps left and writes the terminator symbol. -

- -

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

- -

- An address space is the set of addresses that would be placed into correspondence to cells if we were to step across all those cells while assigning an address to each cell the head is on. Address space is a second order concept. It is because assigning an address to a cell can be a second order concept that we often take it for granted. -

- -

- It is interesting to contemplate if the Natural Number at the basis of the Address Machine instead used Arabic Representation. In that case, an increment or decrement would be a linear time operation due to the carry. Consider a constant time operation on the base machine P, say it steps to the right 5280 cells and writes a mile marker. It would still be a constant time operation no matter the time taken for the address increment. So then consider an operation that is linear time, say a n, where n is the length of the input. Say, for example, it stepped n cells to the right and wrote a marker. If the increment time grows linearly with each step, then what was time n without addresses becomes time n^2 with them, or polynomial time. So indeed using Arabic Representation instead of unary for the address would be computationally consequential for all but constant time machines, if addresses were kept track of in the first order. -

- -

- As of the time of this writing, real machines keep the illusion of constant time Arabic Representation for addresses due to fixed width clocked operations. When the width is fixed, and that fixed number is small enough that interconnect delay does not dominate over computation element delay, adder time tends to be logarithmic. The same is true of the related problem of address decoding. Thus an add can be performed within 'one clock tick'. Native address arithmetic operations on modern machines are always done in this manner. Perhaps there exists a special problem, such as pointer swizzling, where address arithmetic would come under software control. -

- -

- The model used here to define an address is analogous to keeping a pointer into memory, and then using that pointer value as the address. Each step then increments or decrements the pointer. On a real machine, to access memory requires sending that pointer on a trip through a virtual memory system perhaps, and then through an address decoder. In the Turing Machine model, the head directly indicates a location, so it is more akin to the output of the memory decoder, though unlike the output of a memory decoder, it is stateful, i.e., a persistent value that can be moved incrementally. The analogy with the Turing Machine model holds due to the fiction of a constant decode time, as described in the prior paragraph. -

- -

- At a higher level, that virtual memory system level, the memory architecture begins to look more like that of a Turing Machine. The translation lookaside buffer provides stateful location context, and the neighbor relationship between pages might be taken into account for performance reasons. However, once a program starts performing at virtual memory page fetch times instead of local system memory access times, we say that it is page thrashing and know it will become too slow to wait on, no matter its computation complexity class. -

- -

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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Memory TierReal World LatencyScaled DelayScaled Arrival EraHistorical Context
L1 Cache Hit1 ns3 days-0043-03-18Three days after the assassination.
DRAM (Main memory)100 ns300 days-0042-01-09Nearly a year later, during the Liberators' civil war.
NVMe SSD Page Swap15 µs45,000 days0080123 years later, exactly as the Colosseum is completed in Rome.
SATA SSD Page Swap100 µs300,000 days0778821 years later, during the reign of Charlemagne and the Frankish Empire.
Magnetic HDD Page Swap10 ms30,000,000 days82092Tens of thousands of years in the future, long after current human civilizations are dust.
- -

This is why computer architects spend almost all of their effort designing computers that execute as many instructions per cycle as possible within a memory subsystems that has a high statistical chance of executing in the lower levels of the memory abstraction stack. As a demonstration of this, there is not a single chapter on computation theory in Hennessy and Patterson's Computer Architecture: A Quantitative Approach. John L. Hennessy and David A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed. (Cambridge: Morgan Kaufmann, 2017).

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Chapter 1Fundamentals of Quantitative Design and Analysis
Chapter 2Memory Hierarchy Design
Chapter 3Instruction-Level Parallelism and Its Exploitation
Chapter 4Data-Level Parallelism in Vector, SIMD, and GPU Architectures
Chapter 5Thread-Level Parallelism
Chapter 6Warehouse-Scale Computers
Chapter 7Domain-Specific Architectures
Chapter 8The Future of Computing
- - Metrics - -

Address defined area

- -

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

- -

- When cells were defined we noted that they were sets, and that these sets had identity and could be referred to. We needed that to be the case so as to build the tape topology using neighbor properties. Had the tape been singly linked, perhaps we could have used the cells to represent themselves in the properties, but when we doubly linked it, a given cell had to appear in two places, as the right neighbor of its left neighbor, and the left neighbor of its right neighbor, so we stipulated the sets as being identifiable. Initially we did not say how they would be identified. This is common in mathematics, but we soon cleared this up by formalizing the concept of a symbol. -

- -

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

- -

- So we now have two means for identifying a feature. One means is to state its address, and the other is to put a tape machine head on it. -

- -

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

- -

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

- -

Distance and Extent

- -

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

- -

In an analogous manner to defining an address space for a tape, we can define an address space for an area. Accordingly, the leftmost cell of the area is assigned address zero, and the address increments cell by cell going to the right. A finite area will have a finite address space, with the address of the rightmost cell being the largest address in the address space. -

- -

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

- -

Length

- -

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

- -

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

- -

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

- -

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

- -

How cardinality is computed

- -
    -
  1. We set Turing Machine P with its head on the leftmost cell of an area. We mount the initial tape, '·', on the A machine.
    2. -
  2. We step P and simultaneously run the A machine. Stepping stops when P reaches the rightmost cell of the area. At this point, the tape on the A machine holds the address space extent.
    3. -
  3. The A machine is run an additional time. The output on the tape is defined to be the cardinality of the address space, aka the cardinality.
    4. -
- -

Lemma 1, the A machine produces Natural Numbers

- -

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

- -

Lemma 2, cardinality is a natural number

- -

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

- -

Lemma 3, cardinality is not in the address space

- -

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

- -

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

- -

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

- -

The apparent contradiction.

- -

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

- -

Resolution

- -

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

- -

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

- -

- Now here is an interesting result: -

- - - \\aleph_{0} - \\aleph_{-1} = 1 - - -

- Neither machine can be run. However we can compose the two machines, then simplify the composition. When we do so, the ever larger Natural Number machines annihilate each other, and the increment machine remains. The increment machine can be run, so we end up with an output value. -

- - -

Size

- -

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

diff --git a/document/temp3.html b/document/temp3.html deleted file mode 100644 index bf2d55f..0000000 --- a/document/temp3.html +++ /dev/null @@ -1,257 +0,0 @@ - - -Area and partitioning - -

- We call a subset of contiguous cells from a tape an area. An area with a single cell is called a singleton, one with two cells is called a pair. An area has a leftmost cell and a rightmost cell; for a singleton area, those will both be the same cell. Because we are currently evaluating the standard open ended Turing Machine tape, an area sitting on the left end of the tape has no left neighbor cell. If the area is open on the right, it has no right neighbor cell. Otherwise, a finite area has a left neighbor cell and a right neighbor cell that are not in the area. -

- -

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

- -

Head partition

- -
    -
  1. The left side: if the head is on the leftmost cell, this set does not exist. Otherwise, it is a finite set containing all of the cells to the left of the head cell.
    2. -
  2. Head: the head cell.
    3. -
  3. The right side: the infinite set extending rightward from the right neighbor of the head cell.
    4. -
- -

Leftmost/remaining partition

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

Active area partition

- -

- A nonempty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: -

- -
    -
  1. The left empty tail: if the leftmost cell of the tape is an alphabet cell, this area does not exist. Otherwise, it consists of the leftmost cell and the empty cells, if any, to the right of the leftmost cell, up to the first alphabet cell.
    2. - -
  2. Active area: a finite area for computational problems, containing the cells extending from the leftmost alphabet cell up to and including the rightmost alphabet cell. It is possible that the leftmost alphabet cell and the rightmost alphabet cell will be the exact same cell.
    3. - -
  3. The right empty tail: the infinite set extending from the right neighbor of the rightmost cell of the active area, extending rightward.
    4. -
- -

Area implied partition

- -

- Given any one area on a tape, a three part partition is implied. -

- -
    -
  1. The left side: if the given area includes the leftmost cell of the tape, this set does not exist. Otherwise, it is a finite set containing all of the cells to the left of the given area.
    2. -
  2. The given area.
    3. -
  3. The right side: the infinite set extending rightward from the rightmost cell of the given area.
    4. -
- -

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

- -

- The active area partition of a tape only works for tapes that have at least one alphabet cell. As soon as a machine does its first write of an alphabet symbol, it is known the tape has at least one alphabet symbol. However, what if a tape of unknown status, whether completely empty or containing an alphabet cell, is mounted on a tape machine, and it is desired that the machine recognize if the tape is empty or has an alphabet cell? This is the equivalent problem of looking for the leftmost cell of an active area. -

- -

- Recognizing that a tape is empty is generally impossible. Suppose it were attempted, and a machine started scanning the tape rightward from the leftmost cell; for every cell that is discovered to be empty, the machine would have to scan further rightward to check for an alphabet cell. If the tape is truly empty, the recognizer would never stop scanning, so no decision would ever be rendered. -

- -

The impossibility of recognizing the rightmost cell of the active area

- -

- In general, a Turing Machine cannot step across a tape reading cells to recognize the rightmost cell of the active area, or equivalently, the leftmost cell of the right empty tail. Suppose a recognizer attempted this by starting in the active area and stepping right, and the machine discovered an empty cell. The machine would be unable to distinguish between the case of said empty cell being embedded within the active area (meaning more alphabet cells lie further to the right), or the case where said cell is genuinely the leftmost cell of the right tail. To resolve the ambiguity, the machine would be obligated to continue stepping right. Yet, there would never come a time where finding another empty cell would avoid leading back to the exact same case ambiguity, so the machine would forever step right without returning a decision. -

- -

- It follows that if knowledge of the end of the active area is needed, this information must be encoded as a message. For example, a special symbol can be reserved in the alphabet specifically to serve as the end of active area marker. Each time a machine steps beyond the current end of active area marker and does a write, it writes the marker in the right neighbor cell, and goes back and erases the old mark. This method is related to communications theory and the science of signaling. Here, the active area marker is an out of band control signal. -

- -

- If a tape is written by an initializing tape machine, unmounted, and then mounted on a second analyzing tape machine, the analyzing tape machine is starting with a populated tape. Similarly, a mathematician can, by decree, define an initial tape that holds predefined alphabet symbols. In such a scenario, the initializing machine and the analyzing machine must use a shared communication protocol for signaling the end of the active area. They can not operate independently or the analyzing machine would not be able to find the end of the active area. This shared protocol then represents information held by a mediator, said mediator could be used at a higher level to write the control for the two machines, or it could be consulted when the two machines are run. Hence, the mediator is either an author, or a service provide, or possibly both. -

- -

- By definition, a computation must finish in a finite number of steps. It follows that the active area when a Turing Machine halts a computation will always be finite. Consequently, if a Turing Machine initially starts working with a tape that was computed by another Turing Machine, the length of the input will be finite. Still, that input will be in the active area, so the receiving Turing Machine will need to read control data left on the tape under a common communication protocol to be able to find the bounds of the input area. -

- -

- When an input tape is provided as a general mathematical object, either decreed by definition or perhaps abstracted from 'what a Turing Machine computation would produce in the limit of step count', then the input can be either finite or infinite. -

- -

In band and out of band control

- -

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

- -

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

- -

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

- -

Virtual cells

- -

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

- -

Now imagine we define a Turing Machine such that when it steps right, it steps to the right neighbor area, and when it steps left, if there is a left area, it steps to that, otherwise it returns a left of leftmost symbol. The read instruction reads all of the cells in the area, and similarly the write instruction writes them all. Then for this machine the areas are virtual tape cells. -

- -

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

- -

Virtual tape

- -

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

- -

Now suppose defining a Turing Machine that initially has the head on the leftmost cell of a specific area. When step left is called, the tape transport immediately returns the left of leftmost symbol, independent of whether the area is actually at the physical left end of the tape or not. -

- -

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

- -

Partitions on a finite virtual tape

- -

- When a Turing Machine operates on a finite virtual tape, the structural logic of the partitions established earlier must be updated to reflect the absolute rightward boundary. -

- -
    -
  1. For the Head partition and Area implied partition, the right side is no longer infinite. It is a finite set containing all cells extending from the right neighbor of the head (or area) up to the absolute rightmost cell of the virtual tape. If the head (or area) includes the rightmost cell of the virtual tape, the right side set does not exist.
    2. -
  2. For the Leftmost/remaining partition, the remaining area is now a finite set terminating at the rightmost cell of the virtual tape.
    3. -
  3. For the Active area partition, the right empty tail is similarly a finite set extending to the rightmost boundary of the virtual tape. If the rightmost alphabet cell occupies the rightmost cell of the virtual tape, the right empty tail does not exist.
    4. -
--- - Area and partitioning - -

- We call a subset of contiguous cells from a tape an area. An area with a single cell is called a singleton, one with two cells is called a pair. An area has a leftmost cell and a rightmost cell, for a singleton area, those will both be the same cell. A finite area, that is not sitting on the end of the tape, will have a left neighbor cell and right neighbor cell that are not in the area. If the area is sitting on the end of the tape there will be no left neighbor cell. If the area is open on the right, there will be 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. An area can also be partitioned, which leads to nested areas. -

- -

Head partition

- -
    -
  1. The left side: a potentially empty finite set containing all of the cells to the left of the head cell.
    2. -
  2. Head: the head cell.
    3. -
  3. The right side: the infinite set extending rightward from the right neighbor of the head cell.
    4. -
- -

Leftmost/remaining partition

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

Active area partition

- -

- A nonempty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: -

- -
    -
  1. The left empty tail: this area is empty when the leftmost cell is nonempty. Otherwise, it consists of the leftmost cell and the empty cells, if any, to the right of the leftmost cell, up to the first alphabet cell.
    2. - -
  2. Active area: a finite area for computational problems, containing the cells extending from the leftmost alphabet cell up to and including the rightmost alphabet cell. It is possible that the leftmost alphabet cell and the rightmost alphabet cell will be the exact same cell.
    3. - -
  3. The right empty tail: the infinite set extending from the right neighbor of the rightmost cell of the active area, extending rightward.
    4. -
- -

Area implied partition

- -

- Given any one given area on a tape a three part partition is implied. -

- -
    -
  1. The left side: a potentially empty finite set containing all of the cells to the left of the given area.
    2. -
  2. The given area.
    3. -
  3. The right side: for a tape, the infinite set extending rightward from the rightmost cell of the given area.
    4. -
- -

Similarly for a given nested area within a containing area:

- -
    -
  1. The left side: a potentially empty finite set containing all of the cells to the left of the given area's leftmost cell, to the leftmost cell of the containing area.
    2. -
  2. The given area.
    3. -
  3. The right side: for a finite containing area, this is a potentially empty finite set containing all of the cells to the right of the given area's rightmost cell. For a finite nested area inside of an open on the right containing area, this consists of all the cells to the right of the rightmost cell in the nested area. If both the nsted area and the containing area are open on the right, there is no right tail.
    4. -
- - -

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

- -

- The active area partition of a tape only works for tapes that have at least one alphabet cell. As soon as a machine does its first write of an alphabet symbol, it is known the tape has at least one alphabet symbol. However, what if a tape of unknown status, whether completely empty or containing an alphabet cell, is mounted on a tape machine, and it is desired that the machine recognize if the tape is empty or has an alphabet cell? This is the equivalent problem of looking for the leftmost cell of an active area. -

- -

- Recognizing that a tape is empty is generally impossible. Suppose it were attempted, and a machine started scanning the tape rightward from the leftmost cell; for every cell that is discovered to be empty, the machine would have to scan further rightward to check for an alphabet cell. If the tape is truly empty, the recognizer would never stop scanning, so no decision would ever be rendered. -

- -

The impossibility of recognizing the rightmost cell of the active area

- -

- In general, a Turing Machine cannot step across a tape reading cells to recognize the rightmost cell of the active area, or equivalently, the leftmost cell of the right empty tail. Suppose a recognizer attempted this by starting in the active area and stepping right, and the machine discovered an empty cell. The machine would be unable to distinguish between the case of said empty cell being embedded within the active area (meaning more alphabet cells lie further to the right), or the case where said cell is genuinely the leftmost cell of the right tail. To resolve the ambiguity, the machine would be obligated to continue stepping right. Yet, there would never come a time where finding another empty cell would avoid leading back to the exact same case ambiguity, so the machine would forever step right without returning a decision. -

- -

- It follows that if knowledge of the end of the active area is needed, this information must be encoded as a message. For example, a special symbol can be reserved in the alphabet specifically to serve as the end of active area marker. Each time a machine steps beyond the current end of active area marker and does a write, it writes the marker in the right neighbor cell, and goes back and erases the old mark. This method is related to communications theory and the science of signaling. Here, the active area marker is an out of band control signal. -

- -

- If a tape is written by an initializing tape machine, unmounted, and then mounted on a second analyzing tape machine, the analyzing tape machine is starting with a populated tape. Similarly, a mathematician can, by decree, define an initial tape that holds predefined alphabet symbols. In such a scenario, the initializing machine and the analyzing machine must use a shared communication protocol for signaling the end of the active area. They can not operate independently or the analyzing machine would not be able to find the end of the active area. This shared protocol then represents information held by a mediator, said mediator could be used at a higher level to write the control for the two machines, or it could be consulted when the two machines are run. Hence, the mediator is either an author, or a service provide, or possibly both. -

- -

- By definition, a computation must finish in a finite number of steps. It follows that the active area when a Turing Machine halts a computation will always be finite. Consequently, if a Turing Machine initially starts working with a tape that was computed by another Turing Machine, the length of the input will be finite. Still, that input will be in the active area, so the receiving Turing Machine will need to read control data left on the tape under a common communication protocol to be able to find the bounds of the input area. -

- -

- When an input tape is provided as a general mathematical object, either decreed by definition or perhaps abstracted from 'what a Turing Machine computation would produce in the limit of step count', then the input can be either finite or infinite. -

- -

In band and out of band control

- -

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

- -

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

- -

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

- -

Virtual cells

- -

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

. - -

Now imagine we right a Turing Machine, such that when it steps right, it steps to the right neighbor area, and when it steps left, if there is a left area, steps to that, otherwise gives a left of leftmost error. The read instruction reads all of the cells in the area, and similarly the write instruction writes them all. Then for this machine the areas are virtual tape cells. -

- -

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

- -

Virtual tape

- -

Now suppose defining a Turing Machine that initially has the head on the leftmost cell of an area, and when step left is called, it immediately throws the left of leftmost error, independent of whether the area is at the left end of the tape or not. Suppose further, that if the area is finite, and said machine attempts to step right from the rightmost cell of the tape, that it instead throws the right of rightmost error. Such a machine defines a virtual tape over an area. -

- diff --git a/document/with_x_variable.png b/document/with_x_variable.png deleted file mode 100644 index 6294bd2..0000000 Binary files a/document/with_x_variable.png and /dev/null differ