From: Thomas Walker Lynch Date: Wed, 26 Aug 2026 15:40:16 +0000 (+0000) Subject: midst reorg checkpoint X-Git-Url: https://git.reasoningtechnology.com/Realizable_Machine.svg?a=commitdiff_plain;h=15556b396730c2826bb858c9c77fc8355dddb0cf;p=TM-2026 midst reorg checkpoint --- diff --git a/document/book/HU_style_TM_reverse.png b/document/book/HU_style_TM_reverse.png deleted file mode 100644 index 1aae475..0000000 Binary files a/document/book/HU_style_TM_reverse.png and /dev/null differ diff --git a/document/book/TM-2026.html b/document/book/TM-2026.html index 9b08b2f..7c9c20e 100644 --- a/document/book/TM-2026.html +++ b/document/book/TM-2026.html @@ -1,3 +1,32 @@ + + + @@ -201,6 +230,8 @@ Logic +

Frege and Russell and Whitehead began from logic because they took it to be the foundation. In this book the machine is the foundation, and logic is among its phenomena. This chapter has as a purpose to establish language for discussion, rather than being a starting point of the work itself.

+ Propositional calculus @@ -549,7 +580,7 @@ - + The definition of Computational Naturalism

Our courtrooms, legislatures, and debating societies establish rules for adversarial contest. Those rules instill in our culture the expectation that progress is made by choosing a winner. Yet a dialectic requires a structure. @@ -2057,7 +2088,7 @@

- RTM reverse machine + RTM reverse machine
Figure . The Realizable Machine that reverses a binary string @@ -2639,1387 +2670,1644 @@ - - - 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. -
- List . The three areas of the head partition - - -

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

- - + + The reversal + + - - Leftmost/remaining partition + + + Symbol - - -
    -
  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. -
- List . The two areas of the leftmost and remaining partition - + + Natural Symbol +

The design for the Realizable Machine was given in chapter . On that machine there was a column of patch panel holes said to be symbols for gating next state transitions. The presence of a symbol could be ascertained by its effect on the machine by observing the indicator lights, or more directly if the observer is allowed and facilitated to probe the machine with a voltage meter. Alternatively, the symbols could be enumerated in the abstract, as the maker of the control panel did, when he wrote symbol names next to each of the symbol holes. These are all natural actions. When there are merely two such symbols the machine is said to be a "binary" machine. +

- - Active area partition + + Conventionally defined symbol

- A nonempty tape, one with at least one cell holding an alphabet symbol, can be partitioned into the following areas: + 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. (Here we speak at the metamathematical level, where the objects being compared are the symbol instances themselves, rather than anything that might be bound to the symbol. binding is discussed in section .)

- - -
    -
  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. -
- List . The three areas of the active area partition - -

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

- - - - 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. + 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 impossibility of recognizing an empty tape + + Naturally derived Math Symbol

- 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. + Because the Realizable Machine runs programs, it is possible to extend the notion of the Natural Symbol to that of the symbol of mathematics. Accordingly, the symbol of mathematics is defined as a program that produces symbol instances. A new symbol instance of the given symbol is then made, say, by calling a symbol factory’s make function. All of the symbol instances made by the factory constitute the members of corresponding ‘made by’ equivalence class.

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

-

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

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

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

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

-

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

+

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

-

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

+

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

-

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

+ + Instance implementation -

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

+

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

- - In-band and out-of-band control +

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

-

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

+

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

-

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

+

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

-

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

+

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

- + - - Virtual cells + + Distinctness across contexts -

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.

+

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

-

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

+

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

-

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

+

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

+ - - Virtual tape + + Symbol copy consequentiality -

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

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

-

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

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

-

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

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

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

-

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

+ + + + Alphabet

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

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

-

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

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.

- - Partitions on a finite virtual tape + + Symbol implementation examples

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

- - -
    -
  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. -
- List . The partitions of a finite virtual tape - - - - + + + + /* 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; - - - Metrics + /* Instantiating copies of the symbols: */ + TapeAlphabet cell_1 = SYMBOL_A; + TapeAlphabet cell_2 = SYMBOL_A; - - Address defined area + /* Equality comparison over instances */ + if(cell_1 == cell_2){ + /* Evaluates to True */ + } + + Code . A static symbol factory made with a C enum + -

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

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

-

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

+ + + + #include <string.h> + #include <stdlib.h> + #include <stdio.h> -

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

+ // maximum legal index into the symbol list + #define LIST_EXTENT 3 -

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

+ typedef const char *Instance; + typedef struct{ + Instance *head; + Instance *tail; + Instance *extent; + } List; -

With addresses we can now define an area with two addresses, two Peano Numbers, the address of the leftmost cell, and that of the rightmost cell. All Peano 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. -

+ 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; + } - - Distance and extent + Instance make_symbol(const char *name){ + if(!SYM_LIST.head) return make_list(name); -

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.

+ Instance *pt = SYM_LIST.head; + while(1){ + if( strcmp(*pt ,name) == 0 ) return *pt; -

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

+ if(pt == SYM_LIST.extent){ + fprintf(stderr ,"symbol list overflow for %s\n" ,name); + return NULL; + } -

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

+ if(pt == SYM_LIST.tail){ + *++SYM_LIST.tail = strdup(name); + return *SYM_LIST.tail; + } - + pt++; + } + } - - Length + 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 -

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

+ Instance *pt = SYM_LIST.head; + Instance *pt_tail = SYM_LIST.tail; + while(1){ + puts(*pt); + if(pt == pt_tail) break; + pt++; + } -

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

+ if(e == NULL) printf("e is NULL\n"); + } + + Code . A dynamic symbol factory whose instances are string pointers + + - - Is the cardinality of an open on the right area a Peano 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.

+ + + Binding - - How cardinality is computed + + Tuple and relation + + - - -
    -
  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. -
- List . The three steps for computing the cardinality of an address space - + + 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. +

- - Lemma 1, the A machine produces Peano Numbers + -

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

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

- - Lemma 2, cardinality is a Peano Number +

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 Peano Numbers, and a symbol table is implemented using an array that is indexed into using the key.

-

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

+

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

- + - - Lemma 3, cardinality is not in the address space + + A Turing Machine tape cell -

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.

+

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

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

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

-

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 Peano Numbers Machine.

+ - + - - The apparent contradiction. + + + Mathematical Tape -

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

+

The Realizable Machine is a natural object. We observe its mechanisms, name its parts, and then find symbol representation for them so as to facilitate introspection. In short, we build a model.

- +

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

- - Resolution +

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

-

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 Peano Number because a Peano Number Machine cannot reach it in the first-order.

+

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

-

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

+

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

-

Such a value would be a new Turing Machine, one that composes a call to the never halting Peano 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. -

+

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

- +

+ Mathematically, a Turing Machine tape is a specialized path graph. The neighbor properties are the edges. In this special form, properties are attached to the edges. A Turing Machine has a clock based state controller. Taking a step is an atomic operation. The machine is either in state q_i or in state q_{i+1}, there is no mathematical meaning given to the concept of during a step, which is why no properties are added to the edges of the tape path graph. This is not to say that some analysis of a Turing Machine program won’t take pairs of nodes from the path graph and give them meaning, thus effectively giving properties to the arcs. However, this would not be part of the machine definition, such a program must go through the additional effort of making node pairs, because the machine itself does not provide the program with a feature for attaching properties directly to the neighbor property itself.

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

An example of a non-Turing tape like model is the Emacs vertical line cursor model, where a cursor is said to be between characters. An ASCII file offers no such feature as ‘in between’ characters. Like a Turing Machine tape, a medial character in an ASCII file has a left neighbor and a right neighbor character. Any attempt to represent an in between cursor within the file itself would require inserting more characters into the file under the same model of every medial character having a left and a right character. Consequently, though emacs presents a model where cursor is located in between two characters, this model is only due to the interpretation of the functions’ actual effects presented to users in the documentation. For example, instead of saying a cursor is located upon a character, and that inserting a character inserts the character to the right of the given character, the manual gives the description that the new character is inserted at the cursor location, where said cursor is in between the given character and its right neighbor. Thus the documentation presents the user with one model, which by necessity of using standard library calls to work with files, is built upon another model.

-

- 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 Peano Numbers. We can call this machine \aleph_{-1}. -

+ -

- Now here is an interesting result: -

+ + + The Universal Turing Machine - - - - \aleph_{0} - \aleph_{-1} = 1 - - eq: The difference of two transfinite cardinals is one - +

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

-

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

+

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

+

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

- - +

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

- - Size +

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

-

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

+

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

- - +

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

- - Peano Number + + + + # Phase 1: Both heads scan right to the EOM pivot + L·initial: + read('s' ,0) + jump(s, {EOM: L·Check_Empty, def: L·Scan_Right}) + L·Scan_Right: + right(0) + right(1) + jump(def: L·initial) - - Unary representation + # Phase 2: Setup pointers or short-circuit on empty string + L·Check_Empty: + status(0) + jump(s, {leftmost: L·Empty_Setup, def: L·Setup_Write}) -

- A person can define a Turing Machine that is identical to the recursive definition of Peano Numbers as given by Peano. Giuseppe Peano, Arithmetices principia, nova methodo exposita (Turin: Fratres Bocca, 1889). If a person were to run the Peano Number Machine and observe as it writes to the tape, that person would watch as the Peano Numbers are printed one after another: ‘·s·ss·sss·ssss· ...’. Here ‘·’ represents zero, and ‘s·’ represents one, etc. Because the Peano 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. -

+ L·Empty_Setup: + right(1) + jump(def: L·Write_EOR_Done) -

- In contrast, a function extension version of the Peano 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 Peano Number, as per the sequence that the Peano 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 Peano 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. -

+ L·Setup_Write: + right(1) + left(0) + jump(def: L·Copy_Read) -

- To say that Peano Number A is smaller than Peano Number B is to say that A would occur on the Peano 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. -

+ # Phase 3: The Linear Copy Loop + L·Copy_Read: + read('d' ,0) + status(0) + jump(s, {leftmost: L·Copy_Last, def: L·Copy_Loop}) -

- As such, a person can assign a Peano 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. -

+ L·Copy_Loop: + write('σ' ,0 ,SP) + write('d' ,1) + right(1) + left(0) + jump(def: L·Copy_Read) + + # Phase 4: Final character, advance, and clean halt + L·Copy_Last: + write('σ' ,0 ,SP) + write('d' ,1) + right(1) + jump(def: L·Write_EOR_Done) + + L·Write_EOR_Done: + write('σ' ,1 ,EOR) + halt + + Code . The two-headed reverse controller as linear code with jumps + + +

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

+ +

By separating the control path from the data path, utilizing an integrated symbol alphabet, replacing states with sequential instructions, and introducing an explicit addressable instruction pointer, the theoretical machine has physically crossed the bridge to conventional computing. The resulting architecture is a stored-program, von Neumann-style machine organization.

+ +

Some of the default cases for the jump table unnecessarily jump to the instruction at the next sequential address. Code lacks the regularity to use a computed jump table, so this style of jump table becomes a Lisp cond statement, i.e. sequential conditional tests. So then by using the instructions test, beq (for branch on equal), and jump as control instructions, and rearranging to favor sequential execution, this code becomes:

+ + + + + # Phase 1: Both heads scan right to the EOM pivot + L·initial: + read('s' ,0) + test('s' ,EOM) + beq L·Check_Empty + + # L·Scan_Right (Implicit fall-through) + right(0) + right(1) + jump L·initial + + # Phase 2: Setup pointers or short-circuit on empty string + L·Check_Empty: + status(0) + test('s' ,leftmost) + beq L·Empty_Setup + + # L·Setup_Write (Implicit fall-through) + right(1) + left(0) + + # Phase 3: The Linear Copy Loop + L·Copy_Read: + read('d' ,0) + status(0) + test('s' ,leftmost) + beq L·Copy_Last + + # L·Copy_Loop (Implicit fall-through) + write('σ' ,0 ,SP) + write('d' ,1) + right(1) + left(0) + jump L·Copy_Read + + # Phase 4: Final character, advance, and clean halt + L·Copy_Last: + write('σ' ,0 ,SP) + write('d' ,1) + + L·Empty_Setup: + right(1) + + # L·Write_EOR_Done (Implicit fall-through) + write('σ' ,1 ,EOR) + halt + + Code . The same controller using test, branch and jump instructions + + +

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

+ + + + + + + The Universal Realizable Machine + + + + + + 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. +
+ List . The three areas of the head partition + + +

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. +
+ List . The two areas of the leftmost and remaining partition + + + + + + Active area partition

- The Peano 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. + 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. +
+ List . The three areas of the active area partition + +

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

- - Hindu-Arabic representation - -

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

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

+ + + The impossibility of recognizing an empty tape

- For this discussion, the Hindu-Arabic representation address is variable precision, so it will grow as the count becomes larger. The empty symbol will serve as the terminator. + 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.

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

- - - - increment: - a = TTU.read() - if a == 0 or a == □: - TTU.write(1) - halt - TTU.write(0) - TTU.step() - goto increment - - Code . A controller that increments a binary counter - +

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

-

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

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

- 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. Table lists 7 increments, which is sufficient to reach the maximum count that can be held by a 3 bit counter. + 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.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
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
- Table . The cost in steps of each increment, through the range of a three bit counter - -

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

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

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

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

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

- \text{Average Cost} = \frac{2^{n+2} - 2n - 4}{2^n - 1} = \frac{4(2^n-1)+4-2n-4}{2^n-1} + + + + In-band and out-of-band control

- This simplifies algebraically to: + 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.

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

- Consequently, maintaining an Hindu-Arabic address on a secondary Address Machine remains a constant-time operation in the amortized sense, making it computationally inconsequential to the complexity class of the base machine. However, if a problem were to increment and decrement repeatedly around a binary power count, the behavior would be the limiting logarithmic time due to the length of the counter. An unlucky situation like this is called aliasing. + 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.

- - The Computability of Length and Unbounded Zeros -

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

+ + Virtual cells -

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

+

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.

 - - The Representation of Zero and Structural Emptiness -

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

+ + The subroutine call + + -

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

-

Structurally, this forces a design choice between two options:

- - -
    -
  • Using an empty sequence [] and arbitrarily mapping it to zero. This allows a length function to return zero naturally, as the empty sequence is never scanned.
    • -
  • Using a lone zero symbol [0], which introduces an effective length concept where [0] must be treated as though it has zero length in algorithmic operations.
    • -
- List . The two options for representing zero - + + Virtual tape -

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

+

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

- - Numeric value +

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

-

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

+

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

-

A person interprets these sequences as numbers by using a weighted sum.

+

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

- a = \sum_{i=0}^n x_i \cdot ten^i +

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

-

Here a is a numeric value, so it is written in lower case. Each x_i is the ith component of the sequence X. The value x_i is also known as the ‘ith digit’ of the number. The value ten is called the base or the radix of the number. It is fortunate that ten is so well known that it has a name, because otherwise an author is tempted to write the base while using the exact representation that he is trying to define. Although this function gives numeric meaning to our digit sequences, performing the suggested computation is pointless. The result is a number, and a person must represent that number, resulting in the exact sequence that was given as the input to the function in the first place.

+

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

-

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

+ -

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

+ + 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. +
+ List . The partitions of a finite virtual tape + + - - Meaning of the word digital + + + Software + + + + A routine held as data + + -

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

+ + Interface and instance + + -

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

+ + Side effect and transactional behavior + + -

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

+ + + + + The TTU API + + + + The primitive interface + + -

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

+ + Nomenclature + + -

To add digit values on a mechanical computer, the two gears in question were mechanically connected. When one rotated back to zero, the other rotated up to the sum, possibly tipping a carry bar along the way. On ENIAC, one ring counter gated pulses to its partner while counting down. While pulses were gated to it, the second ring counter counted up, optionally setting a carry flip-flop.

+ + Iteration + + -

Hence the term digital initially meant both being discrete and making use of ten-state logic. If a person examines the control levers of the mechanical machines, or the control signals of ENIAC, he finds two-state switch logic, but computation units processed numbers consisting of ten-state digits, mimicking human computers. Early computing work gave us more than the techniques we take for granted today; it gave us words such as gate, register, and index.

+ + Quantifiers + + -

Earlier, Claude Shannon and others wrote extensively on methods for simplifying switch logic, making it apparent that direct binary computation could be performed. The first electronic computer to do so was the Atanasoff-Berry machine developed in the late 1930s. Because there are two states in switch logic, it is maximally efficient to use a base two number system for arithmetic. In such an arithmetic system, each binary digit has the value of either zero or one. It is conventional to shorten the term binary digit to bit. John von Neumann assigned Atanasoff to audio work during World War II, so the Atanasoff-Berry machine remained unused in a basement at Iowa State University.

+ + Generators and recursion + + -

Binary computation prevailed. By the 1950s almost all discrete state computers used two-state switch logic for computation. Still, the term digital continued to describe them. This leads to some curious naming conventions. For example, the company Digital Equipment Corporation, which began shipping computers in 1959, exclusively built binary computers. As another example, an engineer who studies modern digital electronics will never see wheels or decade counters used to implement operations in an ALU. Though the term digital continues to refer to computing with discrete state digits, the term has lost the connotation that there must be exactly ten of those states.

+ + Signaling emptiness + + -

Today, computing based on ten-state digits, such as what is found on handheld calculators, is known as decimal computing. If a machine made use of 256-state digits, it would be neither decimal nor binary. Because we lack a special name for the number 256, a person states that such a computer uses base 256 digits and that it is a base 256 computer. Decimal computing, binary computing, and base 256 computing are all examples of digital computing. Independent of the base for computation, control signals are almost universally on or off. We say these are Boolean or binary valued, sometimes referring to their values as one or zero, but note they represent logical states rather than numbers.

+ + Lengthening the tape, and what it costs + + -

As computer implementations moved from ten-state logic to two-state logic, it was difficult to completely abandon base ten number systems, particularly in business applications where users expect dollars and cents results that match manual computations, even when fractions and rounding are involved. Hence, IBM designed a scheme whereby groups of 4 bits represent the decimal digits; this code is called binary coded decimal or BCD. A machine which processes numbers using BCD has a decimal architecture.

+ + Destructive operations + + -

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

+ + Tape entanglement + + + + Second order machines + - - Scanning-Order and Digit-Order + + Streaming and transforms + + -

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

+ + Interface summary + + -
- Writing from right to left the sequence [7, 8, 9] without notation is 987. -
+ + + + Predicate logic derived + + + + + Address -

When reversed this becomes:

-
- .987 si noitaton tuohtiw [9 ,8, 7] ecneuqes eht thgir ot tfel morf gnitirW -
+

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

-

Following the 1,000-year-old convention, I did not reverse the order of the digits of the number. For the reversed sentence to make sense, I changed ‘tfel ot thgir’ (right to left) to ‘left to right’, which is the sort of adaptation that Middle Ages translators did not universally apply. Also, I changed the brackets so that they still enclose the sequence components; otherwise, they point outward. When reading the number, the eye first lands on a digit of unknown weight. A person must scan further right to find the one’s place, then scan back while counting the digits to make sense of the number. Reversing the string is insufficient; a person must understand the sentence and change the phrase "right to left", to "left to right".

-

Now consider starting with the exact same right to left string as the early translators did, but instead of making an exception for numbers, we literally reverse the entire string:

+

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

-
- Writing from right to left the sequence [7, 8, 9] without notation is 789. -
+

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

-

Now both the scan order of the sequence and the digits are identical. This maintains the property designed into the original Indian Numbers. Note, that 789 here is still thirteen away from one thousand.

+

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

-

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

+

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

-

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

+

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

-

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

+

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

+ +

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

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
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.
+ Table . Memory tier latency, scaled so that one clock tick lasts one day + -

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

+

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

- + - - Binary, Octal, Hexadecimal, BCD + + + + Metrics -

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

+ + Address defined area - \sum_{i=0}^n x_i \cdot two^i +

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

-

As with sequences of decimal digits, a person drops the sequence notation to yield strings of bits. Similar to decimal digit strings, there are two options for writing the string: most-significant-digit-first, or least-significant-digit-first.

+

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

-

Although both strings of binary digits and strings of decimal digits grow in length logarithmically when counting, binary strings grow more than twice as fast. The expansion to a length two string occurs immediately at the count of two. Length expands to three at a count of four, and then to a string of length four at a count of eight. While incrementing to eight, the binary digit string has already expanded to length four, yet for the exact same count, a decimal digit string remains one digit long.

+

+ When discussing symbols we noted they could be Peano 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. +

-

Writing such long strings is inefficient, so programmers group bits. When bits are grouped in threes, the base is eight instead of two. This is called octal notation, using one of the symbols 0, 1, 2, 3, 4, 5, 6, or 7 for the octal digit values.

+

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

- - 000 - 001 - 010 - 011 - 100 - 101 - 110 - 111 - +

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

-

In the 1960s, computer panels featured switches and lights organized in threes, and coding forms were filled out in octal. Today, documents showing bit strings universally use groups of fours. Such a digit has 16 values, utilizing 0 through 9, and continuing with the letters a, b, c, d, e, and f. This is known as the hexadecimal system, often shortened to hex.

+

With addresses we can now define an area with two addresses, two Peano Numbers, the address of the leftmost cell, and that of the rightmost cell. All Peano 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. +

- - 0000 - 0001 - 0010 - 0011 - 0100 - 0101 - 0110 - 0111 - 1000 - 1001 - 1010 - 1011 - 1100 - 1101 8 - 1110 - 1111 - + -

The table of hexadecimal digits is twice as long as the table of octal digits because each added bit doubles the table size.

+ + Distance and extent -

Another common grouping is the byte. This name is word play on the term bit. Today a byte is universally a group of eight bits; however, historical computers used other lengths, ranging from six to twelve bits. Vestiges of that past remain. K&R’s "C Programming Language" leaves the length of a byte unspecified. The designers of UTF-8 sought clarity regarding groups of eight, naming such a group an octet rather than a byte.

+

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.

-

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

+

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

-

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

+

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

-

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

+ - - 0000 - 0001 - 0010 - 0011 - 0100 - 0101 - 0110 - 0111 - 1000 - 1001 - + + Length -

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

+

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

-

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

+

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

-

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

+ -

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

+ + Is the cardinality of an open on the right area a Peano 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.

- - Allocation + + How cardinality is computed -

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

+ + +
    +
  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. +
+ List . The three steps for computing the cardinality of an address space + -

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

+ -

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

+ + Lemma 1, the A machine produces Peano Numbers -

For any allocated boundary, there remains the statistical possibility that a computed number will exceed the allocation, resulting in an overflow error. To establish rigorous allocations, a programmer must evaluate how much numbers grow via applied operations, and how many of those operations the system executes. This latter constraint ties directly to the projected lifespan of the task.

+

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

-

Universally, a program cannot analyze another arbitrary program and determine how many steps it will take before stopping, or if it will ever stop. Even in specific bounded cases, the analysis is highly complex, and the programmer frequently skips it unless the code drives a life-critical application. Because data lengths expand during runtime, users operate under the threat of allocation overflow. If the allocation overflows, there is a high probability the program will stop and emit an error, or it will continue executing while outputting garbage results. This failure mode does not surprise contemporary users. The real-time computer user experiences catastrophic failure, and the error emerges during accident analysis.

+ -

Conventional system memory is an array of allocation units called bytes. The indexes into this array are system memory addresses. Serving as the minimum addressable allocation unit defines the term byte. The number of bits in a byte is a parameter of the computer architecture, not the compiler.

+ + Lemma 2, cardinality is a Peano Number -

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

+

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

-

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

+ -

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

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

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

+

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.

- - - -
- Figure 10: Left justified, least-significant-digit-first -
- Figure . A left-justified word holding a number least-significant-digit-first - + -

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

+ + Lemma 4, the address space of an open on the right area is identical to the Peano Numbers. - - - -
- Figure 11: Same number using big-endian digit-order -
- Figure . The same number held in big-endian digit-order - +

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 Peano Numbers Machine.

-

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

+ -

Typically, processor registers and buses are one word in length, and a processor loads the entire contents of a memory word into a register as a single atomic operation. Contemporary processors are designed effectively for either little-endian or big-endian number representation; however, once designed for little-endian, the processor is fundamentally incompatible with big-endian, and vice-versa.

+ + The apparent contradiction. -

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

+

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

-

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

+ - + + Resolution - - Bit Order Within Bytes +

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 Peano Number because a Peano Number Machine cannot reach it in the first-order.

-

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

+

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

-

Channel processors bridge the gap between a computer’s system bus and a storage bus connected to storage devices. The storage device designers adhere strictly to the storage bus specification without evaluating the host computer architecture. The compatibility burden relies entirely on selecting a channel processor that respects the established standard. Consequently, unless a programmer explicitly designs bus standards or hardware interfaces, the physical bit order within bytes remains invisible.

+

Such a value would be a new Turing Machine, one that composes a call to the never halting Peano 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. +

-

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

+ -

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

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

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

+

+ 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 Peano Numbers. We can call this machine \aleph_{-1}. +

- +

+ Now here is an interesting result: +

- - Byte Order Within Words + + + + \aleph_{0} - \aleph_{-1} = 1 + + eq: The difference of two transfinite cardinals is one + -

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

+

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

-

Communication channels and storage devices organize payloads strictly as octets, possessing no native structural support for words. Therefore, storing or transmitting a word requires serializing the word into a sequence of bytes, transferring the data, and subsequently reading the data while deserializing the byte stream back into the original word configuration.

-

Our Indian Number derived representations consist of sequences of digits. Words of allocation consist of consecutively addressed bytes. Hardware manages bytes atomically. Any bit encoding for the digits of a number must pack cleanly into bytes, otherwise the digits fracture. Achieving a clean packing requires padding the data with zeros to force alignment to an 8-bit boundary. When a system meets this criterion, treating a number as a sequence of bytes acting as digits maintains structural consistency. Due to this constraint, little-endian and big-endian are routinely classified as byte orders.

+ + -

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

+ + Size - - - -
- Figure 12: In-address-order byte by byte copy -
- Figure . A byte-by-byte copy performed in address order - +

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.

-

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

+ + - - - -
- Figure 13: Reverse order byte copy for words -
- Figure . A reverse order byte copy performed word by word - + + Peano Number -

When the data arrives, there is no way to know where the word boundaries are. Serialization destroys that structural boundary information. Without knowing where the words are, a system cannot determine when to perform the byte order reversal. Therefore, resolving this requires a different approach than the one used for bit order in bytes; the problem transfers into the software layer.

-

Byte order within words becomes an application level design consideration, even though it possesses no structural relevance to applications.

+ + Unary representation -

In protocols like the Internet Protocol (IP), the specification explicitly defines the data offset for the packet header. Code executes stably and efficiently. However, IP lacks context regarding the word locations in the data payload it carries, so IP routes the payload up the abstraction stack, preserving all byte order conflicts.

+

+ A person can define a Turing Machine that is identical to the recursive definition of Peano Numbers as given by Peano. Giuseppe Peano, Arithmetices principia, nova methodo exposita (Turin: Fratres Bocca, 1889). If a person were to run the Peano Number Machine and observe as it writes to the tape, that person would watch as the Peano Numbers are printed one after another: ‘·s·ss·sss·ssss· ...’. Here ‘·’ represents zero, and ‘s·’ represents one, etc. Because the Peano 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. +

-

JSON provides a standard for expressing tagged structured data built from primitive types while using character-only data. The specification dictates how numeric character strings evaluate, allowing both little-endian and big-endian machines to safely exchange JSON character-encoded numeric data. However, converting all numbers to strings and back wastes computational overhead, and transmitting them over a channel consumes excess bandwidth. Both processes expend unnecessary energy.

+

+ In contrast, a function extension version of the Peano 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 Peano Number, as per the sequence that the Peano 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 Peano 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. +

-

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

+

+ To say that Peano Number A is smaller than Peano Number B is to say that A would occur on the Peano 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 Peano 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 Realizable Machine number system +

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

-

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

+

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

- - - - - Address - -

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

+ + Hindu-Arabic representation +

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

-

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

+

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

-

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

+

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

-

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

+

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

-

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

+ + + + increment: + a = TTU.read() + if a == 0 or a == □: + TTU.write(1) + halt + TTU.write(0) + TTU.step() + goto increment + + Code . A controller that increments a binary counter + -

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

+

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

-

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

+

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.

-

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

+

+ 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. Table lists 7 increments, which is sufficient to reach the maximum count that can be held by a 3 bit counter. +

- - - - - + + + +
- - - - - + + + - - - - - - - + + + - - - - - + + + - - - - - + + + - - - - - + + + - - - - - + + + - -
Memory TierReal-World LatencyScaled DelayScaled Arrival EraHistorical Contextinputactioncost (steps)
L1 Cache Hit1 ns3 days-0043-03-18Three days after the assassination.0write 1, halt (result is maximum 1 bit count)2
DRAM (Main memory)100 ns300 days-0042-01-09Nearly a year later, during the Liberators’ civil war.1 write 0, step, write 1, halt4
NVMe SSD Page Swap15 µs45,000 days0080123 years later, exactly as the Colosseum is completed in Rome.01write 1, halt (result is maximum 2 bit count)2
SATA SSD Page Swap100 µs300,000 days0778821 years later, during the reign of Charlemagne and the Frankish Empire.11write 0, step, write 0, step, write 1, halt6
Magnetic HDD Page Swap10 ms30,000,000 days82092Tens of thousands of years in the future, long after current human civilizations are dust.001write 1, halt2
- Table . Memory tier latency, scaled so that one clock tick lasts one day - - -

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

- - - - - - The Universal Turing Machine - -

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

+ + 101 + write 0, step right, write 1, halt + 4 + + + 011 + write 1, halt (result is maximum 3 bit count) + 2 + + + 111 + + + + + Table . The cost in steps of each increment, through the range of a three bit counter + -

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

+

+ The 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] +

-

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

+

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

-

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

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

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

+

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

-

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

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

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

+

+ This simplifies algebraically to: +

- - - - # Phase 1: Both heads scan right to the EOM pivot - L·initial: - read('s' ,0) - jump(s, {EOM: L·Check_Empty, def: L·Scan_Right}) + \text{Average Cost} = 4 - \frac{2n}{2^n - 1} - L·Scan_Right: - right(0) - right(1) - jump(def: L·initial) +

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

- # Phase 2: Setup pointers or short-circuit on empty string - L·Check_Empty: - status(0) - jump(s, {leftmost: L·Empty_Setup, def: L·Setup_Write}) +

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

- L·Empty_Setup: - right(1) - jump(def: L·Write_EOR_Done) + - L·Setup_Write: - right(1) - left(0) - jump(def: L·Copy_Read) + + The Computability of Length and Unbounded Zeros +

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

- # Phase 3: The Linear Copy Loop - L·Copy_Read: - read('d' ,0) - status(0) - jump(s, {leftmost: L·Copy_Last, def: L·Copy_Loop}) +

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

- L·Copy_Loop: - write('σ' ,0 ,SP) - write('d' ,1) - right(1) - left(0) - jump(def: L·Copy_Read) + - # Phase 4: Final character, advance, and clean halt - L·Copy_Last: - write('σ' ,0 ,SP) - write('d' ,1) - right(1) - jump(def: L·Write_EOR_Done) + + The Representation of Zero and Structural Emptiness +

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

- L·Write_EOR_Done: - write('σ' ,1 ,EOR) - halt - - Code . The two-headed reverse controller as linear code with jumps - +

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

-

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

+

Structurally, this forces a design choice between two options:

+ + +
    +
  • Using an empty sequence [] and arbitrarily mapping it to zero. This allows a length function to return zero naturally, as the empty sequence is never scanned.
    • +
  • Using a lone zero symbol [0], which introduces an effective length concept where [0] must be treated as though it has zero length in algorithmic operations.
    • +
+ List . The two options for representing zero + -

By separating the control path from the data path, utilizing an integrated symbol alphabet, replacing states with sequential instructions, and introducing an explicit addressable instruction pointer, the theoretical machine has physically crossed the bridge to conventional computing. The resulting architecture is a stored-program, von Neumann-style machine organization.

+

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

-

Some of the default cases for the jump table unnecessarily jump to the instruction at the next sequential address. Code lacks the regularity to use a computed jump table, so this style of jump table becomes a Lisp cond statement, i.e. sequential conditional tests. So then by using the instructions test, beq (for branch on equal), and jump as control instructions, and rearranging to favor sequential execution, this code becomes:

+ - - - - # Phase 1: Both heads scan right to the EOM pivot - L·initial: - read('s' ,0) - test('s' ,EOM) - beq L·Check_Empty + + Numeric value - # L·Scan_Right (Implicit fall-through) - right(0) - right(1) - jump L·initial +

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

- # Phase 2: Setup pointers or short-circuit on empty string - L·Check_Empty: - status(0) - test('s' ,leftmost) - beq L·Empty_Setup +

A person interprets these sequences as numbers by using a weighted sum.

- # L·Setup_Write (Implicit fall-through) - right(1) - left(0) + a = \sum_{i=0}^n x_i \cdot ten^i - # Phase 3: The Linear Copy Loop - L·Copy_Read: - read('d' ,0) - status(0) - test('s' ,leftmost) - beq L·Copy_Last +

Here a is a numeric value, so it is written in lower case. Each x_i is the ith component of the sequence X. The value x_i is also known as the ‘ith digit’ of the number. The value ten is called the base or the radix of the number. It is fortunate that ten is so well known that it has a name, because otherwise an author is tempted to write the base while using the exact representation that he is trying to define. Although this function gives numeric meaning to our digit sequences, performing the suggested computation is pointless. The result is a number, and a person must represent that number, resulting in the exact sequence that was given as the input to the function in the first place.

- # L·Copy_Loop (Implicit fall-through) - write('σ' ,0 ,SP) - write('d' ,1) - right(1) - left(0) - jump L·Copy_Read +

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

- # Phase 4: Final character, advance, and clean halt - L·Copy_Last: - write('σ' ,0 ,SP) - write('d' ,1) +

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

- L·Empty_Setup: - right(1) + - # L·Write_EOR_Done (Implicit fall-through) - write('σ' ,1 ,EOR) - halt - - Code . The same controller using test, branch and jump instructions - + + Meaning of the word digital -

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

+

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

- +

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

- - - Symbol +

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

- - Natural Symbol +

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

-

The design for the Realizable Machine was given in chapter . On that machine there was a column of patch panel holes said to be symbols for gating next state transitions. The presence of a symbol could be ascertained by its effect on the machine by observing the indicator lights, or more directly if the observer is allowed and facilitated to probe the machine with a voltage meter. Alternatively, the symbols could be enumerated in the abstract, as the maker of the control panel did, when he wrote symbol names next to each of the symbol holes. These are all natural actions. When there are merely two such symbols the machine is said to be a "binary" machine. -

- +

To add digit values on a mechanical computer, the two gears in question were mechanically connected. When one rotated back to zero, the other rotated up to the sum, possibly tipping a carry bar along the way. On ENIAC, one ring counter gated pulses to its partner while counting down. While pulses were gated to it, the second ring counter counted up, optionally setting a carry flip-flop.

- - Conventionally defined symbol +

Hence the term digital initially meant both being discrete and making use of ten-state logic. If a person examines the control levers of the mechanical machines, or the control signals of ENIAC, he finds two-state switch logic, but computation units processed numbers consisting of ten-state digits, mimicking human computers. Early computing work gave us more than the techniques we take for granted today; it gave us words such as gate, register, and index.

-

- 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. (Here we speak at the metamathematical level, where the objects being compared are the symbol instances themselves, rather than anything that might be bound to the symbol. binding is discussed in section .) -

+

Earlier, Claude Shannon and others wrote extensively on methods for simplifying switch logic, making it apparent that direct binary computation could be performed. The first electronic computer to do so was the Atanasoff-Berry machine developed in the late 1930s. Because there are two states in switch logic, it is maximally efficient to use a base two number system for arithmetic. In such an arithmetic system, each binary digit has the value of either zero or one. It is conventional to shorten the term binary digit to bit. John von Neumann assigned Atanasoff to audio work during World War II, so the Atanasoff-Berry machine remained unused in a basement at Iowa State University.

-

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

+

Binary computation prevailed. By the 1950s almost all discrete state computers used two-state switch logic for computation. Still, the term digital continued to describe them. This leads to some curious naming conventions. For example, the company Digital Equipment Corporation, which began shipping computers in 1959, exclusively built binary computers. As another example, an engineer who studies modern digital electronics will never see wheels or decade counters used to implement operations in an ALU. Though the term digital continues to refer to computing with discrete state digits, the term has lost the connotation that there must be exactly ten of those states.

-

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

- +

Today, computing based on ten-state digits, such as what is found on handheld calculators, is known as decimal computing. If a machine made use of 256-state digits, it would be neither decimal nor binary. Because we lack a special name for the number 256, a person states that such a computer uses base 256 digits and that it is a base 256 computer. Decimal computing, binary computing, and base 256 computing are all examples of digital computing. Independent of the base for computation, control signals are almost universally on or off. We say these are Boolean or binary valued, sometimes referring to their values as one or zero, but note they represent logical states rather than numbers.

- - Naturally derived Math Symbol +

As computer implementations moved from ten-state logic to two-state logic, it was difficult to completely abandon base ten number systems, particularly in business applications where users expect dollars and cents results that match manual computations, even when fractions and rounding are involved. Hence, IBM designed a scheme whereby groups of 4 bits represent the decimal digits; this code is called binary coded decimal or BCD. A machine which processes numbers using BCD has a decimal architecture.

-

- Because the Realizable Machine runs programs, it is possible to extend the notion of the Natural Symbol to that of the symbol of mathematics. Accordingly, the symbol of mathematics is defined as a program that produces symbol instances. A new symbol instance of the given symbol is then made, say, by calling a symbol factory’s make function. All of the symbol instances made by the factory constitute the members of corresponding ‘made by’ equivalence class. -

+

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

-

- 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 + + Scanning-Order and Digit-Order -

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

+

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

-

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

+
+ Writing from right to left the sequence [7, 8, 9] without notation is 987. +
-

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

+

When reversed this becomes:

-

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

+
+ .987 si noitaton tuohtiw [9 ,8, 7] ecneuqes eht thgir ot tfel morf gnitirW +
- +

Following the 1,000-year-old convention, I did not reverse the order of the digits of the number. For the reversed sentence to make sense, I changed ‘tfel ot thgir’ (right to left) to ‘left to right’, which is the sort of adaptation that Middle Ages translators did not universally apply. Also, I changed the brackets so that they still enclose the sequence components; otherwise, they point outward. When reading the number, the eye first lands on a digit of unknown weight. A person must scan further right to find the one’s place, then scan back while counting the digits to make sense of the number. Reversing the string is insufficient; a person must understand the sentence and change the phrase "right to left", to "left to right".

- - Instance implementation +

Now consider starting with the exact same right to left string as the early translators did, but instead of making an exception for numbers, we literally reverse the entire string:

-

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

+
+ Writing from right to left the sequence [7, 8, 9] without notation is 789. +
-

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

+

Now both the scan order of the sequence and the digits are identical. This maintains the property designed into the original Indian Numbers. Note, that 789 here is still thirteen away from one thousand.

-

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

+

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

-

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

+

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

-

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

+

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

-

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

+

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

- + - - Distinctness across contexts + + Binary, Octal, Hexadecimal, BCD -

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

+

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

-

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

+ \sum_{i=0}^n x_i \cdot two^i -

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

+

As with sequences of decimal digits, a person drops the sequence notation to yield strings of bits. Similar to decimal digit strings, there are two options for writing the string: most-significant-digit-first, or least-significant-digit-first.

- - +

Although both strings of binary digits and strings of decimal digits grow in length logarithmically when counting, binary strings grow more than twice as fast. The expansion to a length two string occurs immediately at the count of two. Length expands to three at a count of four, and then to a string of length four at a count of eight. While incrementing to eight, the binary digit string has already expanded to length four, yet for the exact same count, a decimal digit string remains one digit long.

- - Symbol copy consequentiality +

Writing such long strings is inefficient, so programmers group bits. When bits are grouped in threes, the base is eight instead of two. This is called octal notation, using one of the symbols 0, 1, 2, 3, 4, 5, 6, or 7 for the octal digit values.

-

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

+ + 000 + 001 + 010 + 011 + 100 + 101 + 110 + 111 + -

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

+

In the 1960s, computer panels featured switches and lights organized in threes, and coding forms were filled out in octal. Today, documents showing bit strings universally use groups of fours. Such a digit has 16 values, utilizing 0 through 9, and continuing with the letters a, b, c, d, e, and f. This is known as the hexadecimal system, often shortened to hex.

-

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

+ + 0000 + 0001 + 0010 + 0011 + 0100 + 0101 + 0110 + 0111 + 1000 + 1001 + 1010 + 1011 + 1100 + 1101 8 + 1110 + 1111 + -

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

+

The table of hexadecimal digits is twice as long as the table of octal digits because each added bit doubles the table size.

- +

Another common grouping is the byte. This name is word play on the term bit. Today a byte is universally a group of eight bits; however, historical computers used other lengths, ranging from six to twelve bits. Vestiges of that past remain. K&R’s "C Programming Language" leaves the length of a byte unspecified. The designers of UTF-8 sought clarity regarding groups of eight, naming such a group an octet rather than a byte.

- - Alphabet +

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

-

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

+

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

-

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

+

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

- + + 0000 + 0001 + 0010 + 0011 + 0100 + 0101 + 0110 + 0111 + 1000 + 1001 + - - Symbol implementation examples +

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

-

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

+

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

- - - - /* 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; +

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

- /* Instantiating copies of the symbols: */ - TapeAlphabet cell_1 = SYMBOL_A; - TapeAlphabet cell_2 = SYMBOL_A; +

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

- /* Equality comparison over instances */ - if(cell_1 == cell_2){ - /* Evaluates to True */ - } - - Code . A static symbol factory made with a C enum - + -

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

+ + Allocation - - - - #include <string.h> - #include <stdlib.h> - #include <stdio.h> +

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

- // maximum legal index into the symbol list - #define LIST_EXTENT 3 +

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

- typedef const char *Instance; - typedef struct{ - Instance *head; - Instance *tail; - Instance *extent; - } List; +

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

- static List SYM_LIST = {NULL ,NULL ,NULL}; +

For any allocated boundary, there remains the statistical possibility that a computed number will exceed the allocation, resulting in an overflow error. To establish rigorous allocations, a programmer must evaluate how much numbers grow via applied operations, and how many of those operations the system executes. This latter constraint ties directly to the projected lifespan of the task.

- 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; - } +

Universally, a program cannot analyze another arbitrary program and determine how many steps it will take before stopping, or if it will ever stop. Even in specific bounded cases, the analysis is highly complex, and the programmer frequently skips it unless the code drives a life-critical application. Because data lengths expand during runtime, users operate under the threat of allocation overflow. If the allocation overflows, there is a high probability the program will stop and emit an error, or it will continue executing while outputting garbage results. This failure mode does not surprise contemporary users. The real-time computer user experiences catastrophic failure, and the error emerges during accident analysis.

- Instance make_symbol(const char *name){ - if(!SYM_LIST.head) return make_list(name); +

Conventional system memory is an array of allocation units called bytes. The indexes into this array are system memory addresses. Serving as the minimum addressable allocation unit defines the term byte. The number of bits in a byte is a parameter of the computer architecture, not the compiler.

- Instance *pt = SYM_LIST.head; - while(1){ - if( strcmp(*pt ,name) == 0 ) return *pt; +

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

- if(pt == SYM_LIST.extent){ - fprintf(stderr ,"symbol list overflow for %s\n" ,name); - return NULL; - } +

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

- if(pt == SYM_LIST.tail){ - *++SYM_LIST.tail = strdup(name); - return *SYM_LIST.tail; - } +

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

- pt++; - } - } +

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

- 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 + + + +
+ Figure 10: Left justified, least-significant-digit-first +
+ Figure . A left-justified word holding a number least-significant-digit-first + - Instance *pt = SYM_LIST.head; - Instance *pt_tail = SYM_LIST.tail; - while(1){ - puts(*pt); - if(pt == pt_tail) break; - pt++; - } +

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

- if(e == NULL) printf("e is NULL\n"); - } - - Code . A dynamic symbol factory whose instances are string pointers + + + +
+ Figure 11: Same number using big-endian digit-order +
+ Figure . The same number held in big-endian digit-order - - +

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

- - - Binding +

Typically, processor registers and buses are one word in length, and a processor loads the entire contents of a memory word into a register as a single atomic operation. Contemporary processors are designed effectively for either little-endian or big-endian number representation; however, once designed for little-endian, the processor is fundamentally incompatible with big-endian, and vice-versa.

- - Property +

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

-

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

+

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

 - - Dictionary and reference + + Bit Order Within Bytes -

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.

+

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

-

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 Peano Numbers, and a symbol table is implemented using an array that is indexed into using the key.

+

Channel processors bridge the gap between a computer’s system bus and a storage bus connected to storage devices. The storage device designers adhere strictly to the storage bus specification without evaluating the host computer architecture. The compatibility burden relies entirely on selecting a channel processor that respects the established standard. Consequently, unless a programmer explicitly designs bus standards or hardware interfaces, the physical bit order within bytes remains invisible.

-

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

+

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

+ +

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

+ +

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

 - - A Turing Machine tape cell + + Byte Order Within Words -

- 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 specific processor architecture features native support for byte data alongside varied word lengths, most commonly 16, 32, and 64 bits (or 4, 8, and 16 bytes).

-

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

+

Communication channels and storage devices organize payloads strictly as octets, possessing no native structural support for words. Therefore, storing or transmitting a word requires serializing the word into a sequence of bytes, transferring the data, and subsequently reading the data while deserializing the byte stream back into the original word configuration.

-

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

+

Our Indian Number derived representations consist of sequences of digits. Words of allocation consist of consecutively addressed bytes. Hardware manages bytes atomically. Any bit encoding for the digits of a number must pack cleanly into bytes, otherwise the digits fracture. Achieving a clean packing requires padding the data with zeros to force alignment to an 8-bit boundary. When a system meets this criterion, treating a number as a sequence of bytes acting as digits maintains structural consistency. Due to this constraint, little-endian and big-endian are routinely classified as byte orders.

- +

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

- + + + +
+ Figure 12: In-address-order byte by byte copy +
+ Figure . A byte-by-byte copy performed in address order + - - - Mathematical Tape +

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

-

The Realizable Machine is a natural object. We observe its mechanisms, name its parts, and then find symbol representation for them so as to facilitate introspection. In short, we build a model.

+ + + +
+ Figure 13: Reverse order byte copy for words +
+ Figure . A reverse order byte copy performed word by word + -

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

+

When the data arrives, there is no way to know where the word boundaries are. Serialization destroys that structural boundary information. Without knowing where the words are, a system cannot determine when to perform the byte order reversal. Therefore, resolving this requires a different approach than the one used for bit order in bytes; the problem transfers into the software layer.

-

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

+

Byte order within words becomes an application level design consideration, even though it possesses no structural relevance to applications.

-

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

+

In protocols like the Internet Protocol (IP), the specification explicitly defines the data offset for the packet header. Code executes stably and efficiently. However, IP lacks context regarding the word locations in the data payload it carries, so IP routes the payload up the abstraction stack, preserving all byte order conflicts.

-

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

+

JSON provides a standard for expressing tagged structured data built from primitive types while using character-only data. The specification dictates how numeric character strings evaluate, allowing both little-endian and big-endian machines to safely exchange JSON character-encoded numeric data. However, converting all numbers to strings and back wastes computational overhead, and transmitting them over a channel consumes excess bandwidth. Both processes expend unnecessary energy.

-

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

+

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

-

- Mathematically, a Turing Machine tape is a specialized path graph. The neighbor properties are the edges. In this special form, properties are attached to the edges. A Turing Machine has a clock based state controller. Taking a step is an atomic operation. The machine is either in state q_i or in state q_{i+1}, there is no mathematical meaning given to the concept of during a step, which is why no properties are added to the edges of the tape path graph. This is not to say that some analysis of a Turing Machine program won’t take pairs of nodes from the path graph and give them meaning, thus effectively giving properties to the arcs. However, this would not be part of the machine definition, such a program must go through the additional effort of making node pairs, because the machine itself does not provide the program with a feature for attaching properties directly to the neighbor property itself.

+ -

An example of a non-Turing tape like model is the Emacs vertical line cursor model, where a cursor is said to be between characters. An ASCII file offers no such feature as ‘in between’ characters. Like a Turing Machine tape, a medial character in an ASCII file has a left neighbor and a right neighbor character. Any attempt to represent an in between cursor within the file itself would require inserting more characters into the file under the same model of every medial character having a left and a right character. Consequently, though emacs presents a model where cursor is located in between two characters, this model is only due to the interpretation of the functions’ actual effects presented to users in the documentation. For example, instead of saying a cursor is located upon a character, and that inserting a character inserts the character to the right of the given character, the manual gives the description that the new character is inserted at the cursor location, where said cursor is in between the given character and its right neighbor. Thus the documentation presents the user with one model, which by necessity of using standard library calls to work with files, is built upon another model.

+ + The Realizable Machine number system - +

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

+ + + Computational Analysis @@ -5140,63 +5428,28 @@ - - Computational Naturalism: the transforms are reversible - -

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

- -

- Where Gödel reduced logic to Peano Numbers, we go the other direction to expand upon logic from Peano 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? -

+ + Logic and neural network equivalence + + - diff --git a/document/book/realizable_reverse.png b/document/book/realizable_reverse.png new file mode 100644 index 0000000..1aae475 Binary files /dev/null and b/document/book/realizable_reverse.png differ