# Patent

## Title
Secure active element machine

## Abstract

Based upon the principle of Turing incomputability, and novel properties of the Active Element Machine, a malware-resistant computing machine is constructed. This new computing machine is a non-Turing, non-register machine (non von-Neumann), called an Active Element Machine (AEM). AEM programs are designed so that the purpose of the computation is difficult to apprehend by an adversary and hijack with malware. These methods can help hinder reverse engineering of proprietary algorithms and hardware design.
Using quantum randomness, the AEM can deterministically execute a universal digital computer program with active element firing patterns that are Turing incomputable. In some embodiments, a more powerful computational procedure is demonstrated than Turing's computational procedure (digital computer procedure). Current digital computer algorithms can be derived or designed with a Turing machine computational procedure. A novel class of computing machines is built where the purpose of the program's execution is difficult to apprehend (Turing incomputable).

## Background
RELATED APPLICATIONS
This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/462,260, entitled “Navajo Active Element Machine” filed Jan. 31, 2011, which is incorporated herein by reference. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/465,084, entitled “Unhackable Active Element Machine” filed Mar. 14, 2011, which is incorporated herein by reference. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/571,822, entitled “Unhackable Active Element Machine Using Randomness” filed Jul. 6, 2011, which is incorporated herein by reference. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/572,607, entitled “Unhackable Active Element Machine Unpredictable Firing Interpretations” filed Jul. 18, 2011, which is incorporated herein by reference. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/572,996, entitled “Unhackable Active Element Machine with Random Firing Interpretations and Level Sets” filed Jul. 26, 2011, which is incorporated herein by reference. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/626,703, entitled “Unhackable Active Element Machine with Turing Undecidable Firing Interpretations” filed Sep. 30, 2011, which is incorporated herein by reference. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/628,332, entitled “Unhackable Active Element Machine with Turing Incomputable Firing Interpretations” filed Oct. 28, 2011, which is incorporated herein by reference. This application claims priority benefit of U.S. Provisional Patent Application Ser. No. 61/628,826, entitled “Unhackable Active Element Machine with Turing Incomputable Computation” filed Nov. 7, 2011, which is incorporated herein by reference.


FIELD
The specification generally relates to computing.



BRIEF DESCRIPTION OF FIGURES AND TABLES
In the following figures and tables, although they may depict various examples of the invention, the invention is not limited to the examples depicted in the figures and tables.
FIG. 1 shows a fire pattern of 0000 for active elements X0, X1, X2, and X3. Elements X0, X1, X2, and X3 don't fire during window W.
FIG. 2 shows a fire pattern of 0001 for active elements X0, X1, X2, and X3. During window W, elements X0, X1, X2 don't fire and X3 fires.
FIG. 3 shows a fire pattern of 0010 for active elements X0, X1, X2, and X3. During window W, only element X2 fires.
FIG. 4 shows a fire pattern of 0011 for active elements X0, X1, X2, and X3. During window W, only elements X2 and X3 fire.
FIG. 5 shows a fire pattern of 0100 for active elements X0, X1, X2, and X3. During window W, only element X1 fires.
FIG. 6 shows a fire pattern of 0010 for active elements X0, X1, X2, and X3 used to compute 1⊕0.
FIG. 7 shows a fire pattern of 0010 for active elements X0, X1, X2, and X3 used to compute 0⊕1.
FIG. 8 shows a fire pattern of 1011 for active elements X0, X1, X2, and X3 used to compute 1⊕1.
FIG. 9 shows a fire pattern of 0100 for active elements X0, X1, X2, and X3 used to compute 0⊕0.
FIG. 10 shows a fire pattern of 0101 for active elements X0, X1, X2, and X3 used to compute (00)=1.
FIG. 11 shows a fire pattern of 0101 for active elements X0, X1, X2, and X3 used to compute (10)=1.
FIG. 12 shows a fire pattern of 0101 for active elements X0, X1, X2, and X3 used to compute (01)=1.
FIG. 13 shows a fire pattern of 1010 for active elements X0, X1, X2, and X3 used to compute (11)=0.
FIG. 14 shows the geometry of a vertical cover.
FIG. 15 shows the geometry of a horizontal cover.
FIG. 16 shows the geometry when the map is not a vertical cover.
FIG. 17 shows the geometry of a vertical cover for the Vertical Covering Fixed Point Theorem in 1.13.
FIG. 18 shows the geometry of a horizontal cover for the Horizontal Covering Fixed Point Theorem in 1.14.
FIG. 19 shows a Turing machine configuration (q, k, T) with the machine in state q, tape head at tape square k and containing alphabet symbol T(k) in tape square k.
FIG. 20 shows the window of execution for one cycle of a periodic point p=[q, 121 212222].
FIG. 21 shows the pertinent parts of the machine configuration used to determine the unit square domain of a left affine map (2.16) or right affine map (2.19).
FIG. 22 shows a Turing machine computational step that corresponds to one iteration of a corresponding left affine function (2.16).
FIG. 23 shows a Turing machine computational step that corresponds to one iteration of a right affine function (2.19)
FIG. 24 shows case A of the definition the Edge Pattern Substitution Operator.
FIG. 25 shows case B of the definition the Edge Pattern Substitution Operator.
FIG. 26 shows case C of the definition the Edge Pattern Substitution Operator.
FIG. 27 shows case D of the definition the Edge Pattern Substitution Operator.
FIG. 28 shows 8 points of the affine map orbit corresponding to the aperiodic machine defined in 6.2.
FIG. 29 shows 4 additional points of the affine map orbit in 6.2.
FIG. 30 shows 9 points of the affine map orbit corresponding to the periodic machine defined in 6.3.
FIG. 31 shows 9 additional points of the affine map orbit corresponding to the periodic machine defined in 6.3.
FIG. 32 shows 7 additional points of the affine map orbit corresponding to the periodic machine defined in 6.3.
FIG. 33 shows a square about point zn referred to in 6.20.
FIG. 34 shows a vertical cover referred to in 6.20.



For each boolean function ƒ: {0, 1}×{0, 1}→{0, 1}, table 1 shows the level set rules used to design an active element machine program that separate elements of {(0, 0), (1, 0), (0, 1), (1, 1)}.
Table 2 shows Minsky's universal Turing machine.
Table 3 shows the Boolean version of the universal Turing machine in table 2.
Table 4 shows the level set rules for η0: the 0th bit of Turing program η in table 3.
Table 5 shows the level set rules for η1: the 1st bit of Turing program η in table 3.
Table 6 shows the level set rules for η2: the 2nd bit of Turing program η in table 3.
Table 7 shows the level set rules for η3: the 3rd bit of Turing program η in table 3.
Table 8 shows the level set rules for η4: the 4th bit of Turing program η in table 3.
Table 9 shows the level set rules for η5: the 5th bit of Turing program η in table 3.
Table 10 shows all sixteen firing patterns of elements X0, X1, X2, X3 which represents four bits that are added using elements C0, C1, C2, C3 and elements P0, P1, P2, P3.
Table 11 shows the amplitudes from elements X0, X1, X2, X3 to elements C0, C1, C2, C3 and thresholds for elements C0, C1, C2, C3. Table 12 shows the amplitudes from elements C0, C1, C2, C3 to elements P0, P1, P2, P3 and thresholds for elements P0, P1, P2, P3.
Table 13 shows four bit multiplication where one four bit number is y3 y2 y1 y0 and the other four bit number is z3 z2 z1 z0 and the result is e7 e6 e5 e4 e3 e2 e1 e0 
Table 14 shows the amplitude and threshold used to compute the value of e0. Table 15 shows the firing patterns for elements S10 and S01 representing the value of products y0 z0 and y0 z1. Table 16 shows the amplitudes from elements S10 and S0l to elements C0l and C11 and the thresholds of C01 and C11. Table 17 shows the amplitude and threshold used to compute the value of e1.
Table 18 shows the firing patterns for elements S20, S11, S02 and C11. Table 19 shows the amplitudes from elements S20, S11 S02, C11 to elements C02, C12, C22 C32 and thresholds of C02, C12, C22 and C32. Table 20 shows the amplitudes from elements C02, C12, C22, C32 to elements P02, P12, P22 and the thresholds of elements P02, P12, P22. Table 21 shows the amplitude and threshold used to compute the value of e2.
Table 22 shows the firing patterns for elements S30, S21, S12, S03, P12 representing the value of products y3 z0, y2 z1, y1 z2 and y0 z3 and the carry value. Table 23 shows the amplitudes from elements S30, S21, S12 and S03 to elements C03, C13, C23, C33, and C43. Table 24 shows the amplitudes from elements C03, C13, C23, C33, and C43 to elements P03, P13, P23 and the thresholds of elements P03, P13, P23. Table 25 shows the amplitude and threshold used to compute the value of e3.
Table 26 shows the firing patterns for elements S31, S22, S13, P13, P22. Table 27 shows the amplitudes from elements S31, S22, S13, P13, P22 to elements C04, C14, C24, C34, C44 and the thresholds of C04, C14, C24, C34 and C44.
Table 28 shows the amplitudes from elements C04, C14, C24, C34, and C44 to elements P04, P14, P24 and the thresholds of elements P04, P14, P24. Table 29 shows the amplitude and threshold used to compute the value of e4.
Table 30 shows the firing patterns for elements S32, S23, P14, P23. Table 31 shows the amplitudes from elements S32, S23, P14, P23 to elements C05, C15, C25, C35 and the thresholds of C05, C15, C25, C35. Table 32 shows the amplitudes from elements C05, C15, C25, C35 to elements P05, P15, P25 and the thresholds of elements P05, P15, P25. Table 33 shows the amplitude and threshold used to compute the value of e5.
Table 34 shows the firing patterns for elements S33, P15, P24. Table 35 shows the amplitudes from elements S33, P15, P24 to elements C06, C16, C26 and the thresholds of C06, C16, C26. Table 36 shows the amplitudes from elements C06, C16, C26 to elements P06, P16 and the thresholds of elements P06, P16. Table 37 shows the amplitude and threshold used to compute the value of e6.
Table 38 shows some details of the four bit multiplication 1110*0111. Table 39 shows some details of the four bit multiplication 1011*1001. Table 40 shows some details of the four bit multiplication 1111*1110. Table 41 shows some details of the four bit multiplication 1111*1111.
BRIEF SUMMARY OF THE INVENTION
What are you trying to do? Why is this compelling?
Based upon the principles of Turing incomputability and connectedness and novel properties of the Active Element Machine, a malware-resistant computing machine is constructed. This novel computing machine is a non-Turing, non-register machine (non von-Neumann), called an active element machine (AEM). AEM programs are designed so that the purpose of the AEM computations are difficult to apprehend by an adversary and hijack with malware. As a method of protecting intellectual property, these methods can also be used to help thwart reverse engineering of proprietary algorithms, hardware design and other areas of intellectual property.
Limitations and Deficiencies of Prior Art
How is it done at present? What are the limitations of present cybersecurity approaches?
Some prior art (approaches) has tried to conceal and protect a computation by enclosing it in a physical barrier, or by using a virtual barrier, e.g. firewall, or private network. The prior art has not been successful at securing computers, networks and the Internet. Operating system weaknesses and the proliferation of mobile devices and Internet connectivity have enabled malware to circumvent these boundaries.
In regard to confidentiality of data, some prior art uses cryptography based on the P≠NP complexity assumption, which relies on large enough computing bounds to prevent breaking the cryptography. In the future, these approaches may be compromised by more advanced methods such as Shor's algorithm, executing on a quantum computing machine.
In the case of homomorphic cryptography <http://crypto.stanford.edu/craig/> its computing operations are about twelve orders of magnitude too slow and the operations execute on a register machine. Homomorphic cryptography assumes that the underlying encryption E operations obey the homomorphism ring laws E(x+y)=E(x)+E(y) and E(x)·E(y)=E(x·y) <http://tinyurl.com/4csspud>. If the encrypted execution is tampered with (changed), then this destroys the computation even though the adversary may be unable to decrypt it. This is analogous to a DDoS attack in that you don't have to be able to read confidential data to breach the cybersecurity of a system. Homomorphic cryptography executing on a register machine along with the rest of the prior art is still susceptible to fundamental register machine weaknesses discussed below.
Some prior art has used the evolution of programs executing on a register machine (von=Neumann architecture) architecture. [Fred Cohen, “Operating Systems Protection Through Program Evolution”, IFIP-TC11 ‘Computers and Security’ (1993) V12#6 (October 1993) pp. 565-584].
The von Neumann architecture is a computing model for a stored-program digital computer that uses a CPU and a separate structure (memory) to store both instructions and data. Generally, a single instruction is executed at a time in sequential order and there is no notion of time in von-Neumann machine instructions: This creates attack points for malware to exploit. Some prior art has used obfuscated code that executes on a von-Neumann architecture. See <http://www.ioccc.org/main.html> on the International Obfuscated C code contest.
In the prior art, computer program instructions are computed the same way at different instances: fixed representation of the execution of a program instruction. For example, the current microprocessors have the fixed representation of the execution of a program instruction property. (See http://en.wikipedia.org/wiki/Microprocessor.) The processors made by Intel, Qualcomm, Samsung, Texas Instrument and Motorola use a fixed representation of the execution of their program instructions. (See www.intel.com http://en.wiki edia.org/wiki/Intel_processor, http://www.qualcomm.com/, www.samsung.com and http://www.ti.com/)
The ARM architecture, which is licensed by many companies, uses a fixed representation of the execution of its program instructions. (See www.arm.com and www.wikipedia.org/wiki/Arm_instruction_set.) In the prior art, not only are the program instructions computed the same way at different instances, there are also a finite number of program instructions representable by the underlying processor architecture. This affects the compilation of a computer program written into the processor's (machine's) program instructions. As a consequence, the compiled machine instructions generated from a program written in a programming language such as—C, JAVA, C++, Fortran, assembly language, Ruby, Forth, LISP, Haskell, RISC machine instructions, java virtual machine, Python or even a Turing machine program—are computed the same way at different instances. This fixed representation of the execution of a program instruction property in the prior art makes it easier for malware to exploit security weaknesses in these computer programs.
Some prior art relies on operating systems that execute on a register machine architecture. The register machine model creates a security vulnerability because its computing steps are disconnected. This topological property (disconnected) creates a fundamental mathematical weakness in the register machine so that register machine programs may be hijacked by malware. Next, this weakness is explained from the perspective of a digital computer program (computer science).
In DARPA's CRASH program <http://tinyurl.com/4 khv28q>, they compared the number of lines of source code in security software written over twenty years versus malware written over the same period. The number of lines of code in security software grew from about 10,000 to 10 million lines; the number of lines of code in malware was almost constant at about 125 lines. It is our thesis that this insightful observation is a symptom of fundamental security weakness(es) in digital computer programs (prior art of register machines): It still takes about the same number of lines of malware code to hijack digital computer's program regardless of the program's size.
The sequential execution of single instructions in the register and von-Neumann machine make the digital computer susceptible to hijacking and sabotage. As an example, by inserting just one jmp WVCTF instruction into the program or changing the address of one legitimate jmp instruction to WVCTF, the purpose of the program can be hijacked.










Malware Instructions (polymorphic variant)




















WVCTF:
mov
eax,
drl




jmp
Loc1



Loc2:
mov
edi,
[eax]



LOWVCTF:
pop
ecx




jecxz
SFMM




inc
eax




mov
esi,
ecx




dec
eax




nop




mov
eax,
0d601h




jmp
Loc3



Loc1:
mov
ebx,
[eax+10h]




jmp
Loc2



Loc3:
pop
edx




pop
ecx




nop




call
edi




jmp
LOWVCTF



SFMM:
pop
ebx




Pop
eax




stc










From a Turing machine (TM) perspective, only one output state r of one TM program, command η(q, a)=(r, b, x) needs to be changed to state m combined with additional hijacking TM commands adjoined to the original TM program. After visiting state m, these hijacking commands are executed, which enables the purpose of the original TM program to be hijacked.
Furthermore, once the digital computer program has been hijacked, if there is a friendly routine to check if the program is behaving properly, this safeguard routine will never get executed. As a consequence, the sequential execution of single instructions cripples the register machine program from defending and repairing itself. As an example of this fundamental security weakness of a digital computer, while some malware may have difficulty decrypting the computations of a homomorphic encryption operation, the malware can still hijack a register machine program computing homomorphic encryption operations and disable the program.
Brief Summary of Novelty and Advantages Over Prior Art
What is novel about the Secure Active Element Machine?
A. A novel non-Turing computing machine—called the active element machine—is presented that has new capabilities. Turing machine, digital computer programs, register machine programs and standard neural networks have a finite prime directed edge complexity. (See definition 4.23.) A digital computer program or register machine program can be executed by a Turing machine. (See [7], [20] and [24]).
An active element machine (AEM) that has unbounded prime directed edge complexity can be designed or programmed. This is important advantage because rules describing a AEM program are not constant as a function of time. Furthermore, these rules change unpredictably because the AEM program interpretation can be based on randomness and in some embodiments uses quantum randomness. In some embodiments, quantum randomness uses quantum optics or quantum phenomena from a semiconductor. The changing the rules property of the AEM programs with randomness makes it difficult for malware to apprehend the purpose of an AEM program.
B. Meta commands and the use of time enable the AEM to change its program as it executes, which makes the machine inherently self-modifying. In the AEM, self-modification of the connection topology and other parameters can occur during a normal run of the machine when solving computing problems. Traditional multi-element machines change their architecture only during training phases, e.g. when training neural networks or when evolving structures in genetic programming. The fact that self-modification happens during runtime is an important aspect for cybersecurity of the AEM. Constantly changing systems can be designed that are difficult to reverse engineer or to disable in an attack. When the AEM has enough redundancy and random behavior when self-modifying, multiple instances of an AEM—even if built for the same type of computing problems—all look different from the inside. As a result, machine learning capabilities are built right into the machine architecture. The self-modifying behavior also enables AEM programs to be designed that can repair themselves if they are sabotaged.
C. The inherent AEM parallelism and explicit use of time can be used to conceal the computation and greatly increase computing speed compared to the register machine. There are no sequential instructions in an AEM program. Multiple AEM commands can execute at the same time. As a result, AEM programs can be designed so that additional malware AEM commands added to the AEM program would not effect the intended behavior of the AEM program. This is part of the topological connectedness.
D. An infinite number of spatio-temporal firing interpretations can be used to represent the same underlying computation. As a result, at two different instances a Boolean function can be computed differently by an active element machine. This substantially increases the AEM's resistance to reverse engineering and apprehension of the purpose of an AEM program. This enables a computer program instruction to be executed differently at different instances. In some embodiments, these different instances are at different times. In some embodiments, these different instances of computing the program instruction are executed by different collections of active elements and connections in the machine. Some embodiments use random active element machine firing interpretations to compute a Boolean function differently at two different instances.
E. Incomputability is used instead of complexity. Incomputability means that a general Turing machine algorithm can not unlock or solve an incomputable problem. This means that a digital computer program can not solve an incomputable problem. This creates a superior level of computational security.
F. Randomness in the AEM computing model. Because the AEM Interpretation approach relies on quantum randomness to dynamically generate random firing patterns, the AEM implementing this technique is no longer subject to current computability theory that assumes the Turing machine or register machine as the computing model. This means that prior art methods and their lack of solutions for malware that depend on Turing's halting problem and undecidability no longer apply to the AEM in this context. This is another aspect of the AEM's non-Turing behavior (i.e. beyond a digital computer's capabilities) that provides useful novel cybersecurity capabilities.
In some embodiments, the quantum randomness utilized with the AEM helps create a more powerful computational procedure in the following way. An active element machine (AEM) that uses quantum randomness can deterministically execute a universal Turing machine (i.e. digital computer program that can execute any possible digital computer program) such that the firing patterns of the AEM are Turing incomputable. An active element machine (AEM) that uses quantum randomness deterministically executes digital computer instructions such that the firing patterns of the active element machine are Turing incomputable. This means that this security method will work for any digital computer program and the capability works for any digital computer hardware/software implementation and for digital computer programs written in C, C++, JAVA, Fortran, Assembly Language, Ruby, Forth, Haskell, RISC machine instructions (digital computer machine instructions, JVM (Java virtual machine), Python and other digital computer languages.
Register machine instructions, Turing machine or digital computer instructions can be executed with active element machine instructions where it is Turing incomputable to understand what the active element machine computation is doing. In these embodiments, the active element machine computing behavior is non-Turing. This enhances the capability of a computational procedure: it secures the computational process (new secure computers) and helps protect a computation from malware.
Why is now a good time?
a. It was recently discovered that an Active Element machine can exhibit non-Turing dynamical behavior. The use of prime directed edge complexity was discovered. Every Turing machine (digital computer program) has a finite prime directed edge complexity. (See 4.20 and 4.23.) An active element machine that has unbounded prime directed edge complexity can be designed using physical randomness. For example, the physical or quantum randomness can be realized with quantum optics or quantum effects in a semiconductor or another quantum phenomena.
b. The Meta command was discovered which enables the AEM to change its program as execution proceeds. This enables the machine to compute the same computational operation in an infinite number of ways and makes it conducive to machine learning and self-repair. The AEM can compute with a language that randomly evolves while the AEM program is executing.
c. It was recently realized that Active Element machine programs can be designed that are connected (in terms of topology), making them resistant to tampering and hijacking.
d. When a Turing machine or register machine (digital computer) executes an unbounded (non-halting) computation, the long term behavior of the program has recurrent points. This demonstrates the machine's predictable computing behavior which creates weaknesses and attack points for malware to exploit. This recurrent behavior in Turing machine and register machine is described in the section titled IMMORTAL ORBIT and RECURRENT POINTS.
e. Randomness can be generated from physical processes using quantum phenomena i.e. quantum optics, quantum tunneling in a semiconductor or other quantum phenomena. Using quantum randomness as a part of the active element machine exhibits non-Turing computing behavior. This non-Turing computing behavior generates random AEM firing interpretations that are difficult for malware to comprehend.
What is novel about the new applications that can be built?
In some embodiments, an AEM can execute on current computer hardware and in some embodiments is augmented. These novel methods using an AEM are resistant to hackers and malware apprehending the purpose of AEM program's computations and in terms of sabotaging the AEM program's purpose; sabotaging a computation's purpose is analogous to a denial of service or distributed denial of service attack. The machine has computing performance that is orders of magnitude faster when implemented with hardware that is specifically designed for AEM computation. The AEM is useful in applications where reliability, security and performance are of high importance: protecting and reliably executing the Domain Name Servers, securing and running critical infrastructure such as the electrical grid, oil refineries, pipelines, irrigation systems, financial exchanges, financial institutions and the cybersecurity system that coordinates activities inside institutions such as the government.
Brief Summary of Prior Art Computing Models
For completeness, a brief introduction to Turing machines is presented a later section. In [32], Alan Turing introduces the Turing Machine, which is a basis for the current digital computer. Sturgis and Shepherdson present the register machine in [31] and demonstrate the register machine's computational equivalence to the Turing machine: a Turing machine can compute a function in a finite number of steps if and only if a register machine can also compute this function in a finite number of steps. The works [7], [20], [21], [22] and [24] cover computability where other notions of computation equivalent to the Turing machine are also described.
In [23], McCulloch and Pitts present one of the early alternative computing models influenced by neurophysiology. In [27], Rosenblatt presents the perceptron model, which has a fixed number of perceptrons and has no feedback (cycles) in its computation. In [25], Minsky and Papert mathematically analyze the perceptron model and attempt to understand serial versus parallel computation by studying the capabilities of linear threshold predicates. In [16], Hopfield shows how to build a content addressable memory with neural networks that use feedback and where each neuron has two states. The number of neurons and connections are fixed during the computation. In [17], Hopfield presents an analog hardware neural network to perform analog computation on the Traveling-Salesman problem, which is NP-complete [12]. Good, suboptimal solutions to this problem are computed by the analog neural network within an elapsed time of only a few neural time constants.
In [18], Hopfield uses time to represent the values of variables. In the conclusion, he observes that the technique of using time delays is similar to that of using radial basis functions in computer science.
In [15], Hertz et al. discuss the Hopfield model and various computing models that extend his work. These models describe learning algorithms and use statistical mechanics to develop the stochastic Hopfield model. They use some statistical mechanics techniques to analyze the Hopfield model's memory capacity and the capacity of the simpler perceptron model.
For early developments on quantum computing models, see [2], [3], [9], [10], [21] and [22]. In [29], Shor discovers a quantum algorithm showing that prime factorization can be executed on quantum computers in polynomical time (i.e. considerably faster than any known classical algorithm). In [13], Grover discovers a quantum search algorithm among n objects that can be completed in cn0.5 computational steps.
In [8], Deutsch argues that there is a physical assertion in the underlying Church-Turing hypothesis: Every finitely realizable physical system can be perfectly simulated by a universal model computing machine operating by finite means. Furthermore, Deutsch presents a quantum generalization of the class of Turing machines: a universal quantum computer that covers quantum parallelism and shows an increase in computing speed. This universal quantum computer does not demonstrate the computation of non-Turing computable functions. For the most part, these prior results on computing models have studied the model's speed of computation, memory capacity, learning ability or have demonstrated that a particular computing model is equivalent to the Turing machine (digital computer)—in terms of computability (see [7] pages 10-12).
Summary of Methods
a. AEM representations are randomly generated that are Turing incomputable to determine their computational purpose.
b. AEM representations are created that are also topologically connected.
c. AEM parallelism is used to solve computationally difficult tasks as shown in the section titled An AEM Program Computes a Ramsey Number.
d. Turing machine computation (digital computer computation) is topologically disconnected as shown by the affine map correspondence in 2.25.
Synthesis of Multiple Methods
In some embodiments, multiple methods are used and the solution is a synthesis of some of the following methods, A-E.
A. An AEM program—with input active elements fired according to b1 b2 . . . bm—accepts [b1 b2 . . . bm] if active elements E1, E2 . . . , En exhibit a set or sequence of firing patterns. In some embodiments, this sequence of firing patterns has Turing incomputable interpretations using randomness.

B. AEM programs are created with an unbounded prime edge complexity. Turing and register machine programs have a finite prime directed edge complexity as shown in the section titled Prime Edge Complexity, Periodic Points & Repeating State Cycles.

C. AEM programs are created with no recurrent points when computation is unbounded with respect to time. This is useful for cybersecurity as it helps eliminate weaknesses for malware to exploit. When a Turing machine or register machine (digital computer) executes an unbounded (non-halting) computation, the long term behavior of the program has recurrent points. The recurrent behavior in a digital computer is described in the section titled Immortal Orbit and Recurrent Points.

D. Multiple AEM firing patterns are computed concurrently and then one can be selected according to an interpretation executed by a separate AEM machine. The AEM interpretation is kept hidden and changes over time. In some embodiments, evolutionary methods using randomness may help build AEMs that utilize incomputability and topological connectedness in their computations.

E. In some embodiments, AEMs programs represent the Boolean operations in a digital computer using multiple spatio-temporal representations, which is further described in the detailed description. In some embodiments, level set methods on random AEM firing interpretations may be used that do not use Boolean functions. This enables a digital computer program instruction to be executed differently at different instances. In some embodiments, these different instances are at different times. In some embodiments, these different instances of computing the program instruction are executed by different collections of active elements and connections in the active element machine.

F. In some embodiments, the parallel computing speed increase of an AEM is substantial. As described in the section titled An AEM Program Computes a Ramsey Number, an AEM program is shown that computes a Ramsey number using the parallelism of the AEM. The computation of Ramsey numbers is an NP-hard problem [12].

DETAILED DESCRIPTION
Although various embodiments of the invention may have been motivated by various deficiencies with the prior art, which may be discussed or alluded to in one or more places in the specification, the embodiments of the invention do not necessarily address any of these deficiencies. In other words, different embodiments of the invention may address different deficiencies that may be discussed in the specification. Some embodiments may only partially address some deficiencies or just one deficiency that may be discussed in the specification, and some embodiments may not address any of these deficiencies.
Active Element Machine Description
An active element machine is composed of computational primitives called active elements. There are three kinds of active elements: Input, Computational and Output active elements. Input active elements receive information from the environment or another active element machine. This information received from the environment may be produced by a physical process.
In some embodiments, information from the environment may come from the physical process of photons originating from sunlight or other kinds of light traveling through space. In some embodiments, information from the environment may come from the physical process of sound. The sounds waves may be received by a sensor or transducer that causes one or more input elements to fire. In some embodiments, the acoustic transducer may be a part of the input elements and each input element may be more sensitive to a range of sound frequencies. In some embodiments, the sensor(s) or transducer(s) may be a part of one or more of the input elements and each input element may be more sensitive to a range of light frequencies analogous to the cones in the retina.
In some embodiments, information from the environment may come from the physical process of molecules present in the air or water. In some embodiments, sensor(s) or transducer(s) may be sensitive to particular molecules diffusing in the air or water, which is analogous to the molecular receptors in a person's nose. For example, one or more input elements may fire if a particular concentration of cinnamon molecules are detected by olfactory sensor(s).
In some embodiments, the information from the environment may originate from the physical process of pressure. In some embodiments, pressure information is transmitted to one or more of the input elements. In some embodiments, the sensor(s) that are a part of the input elements or connected to the input elements may be sensitive to pressure, which is analogous to a person's skin. In some embodiments, sensor sensitive to heat may be a part of the input elements or may be connected to the input elements. This is analogous to a person's skin detecting temperature.
Computational active elements receive messages from the input active elements and other computational active elements firing activity and transmit new messages to computational and output active elements. The output active elements receive messages from the input and computational active elements firing activity. Every active element is active in the sense that each one can receive and transmit messages simultaneously.
Each active element receives messages, formally called pulses, from other active elements and itself and transmits messages to other active elements and itself. If the messages received by active element Ei at the same time sum to a value greater than the threshold and Ei's refractory period has expired, then active element Ei fires. When an active element Ei fires, it sends messages to other active elements.
Let Z denote the integers. Define the extended integers as ={m+kdT: m, kεZ and dT is a fixed infinitesimal}. For more on infinitesimals, see [26] and [14]. The extended integers can also be expressed using the correspondence m+ndT(m, n) where (m, n) lies in Z×Z. Then use the dictionary order (m, {dot over (n)})<(k, l) if and only if (m<k) OR (m=k AND n<l). Similarly, m+ndT<k+ldT if and only if (m<k) OR (m=k AND n<1).
Machine Architecture
Γ, Ω, and Δ are index sets that index the input, computational, and output active elements, respectively. Depending on the machine architecture, the intersections Γ∩Ω and Ω∩Δ can be empty or non-empty. A machine architecture, denoted as (I, , O), consists of a collection of input active elements, denoted as I={Ei: iεΓ}; a collection of computational active elements ={Ei: iεΩ}; and a collection of output active elements O={Ei: iεΔ}.

    Each computational and output active element, Ei, has the following components and properties.
    A threshold θi 
    A refractory period ri where ri>0.
    A collection of pulse amplitudes {Aki: kεΓ∪Ω}.
    A collection of transmission times {τki: kεΓ∪Ω}, where τki>0 for all kεΓ∪Ω.
    A function of time, Ψi(t), representing the time active element Ei last fired. Ψi(t)=sup{s: s<t and gi(s)=1}, where gi(s) is the output function of active element Ei and is defined below. The sup is the least upper bound.
    A binary output function, gi(t), representing whether active element Ei fires at time t. The value of gi(t)=1 if ΣAki(t)>0; where the sum ranges over all kεΓ∪Ω and t≧Ψi(t)+ri. In all other cases, gi(t)=0. For example, gi(t)=0, if t<Ψi(t)+ri.
    A set of firing times of active element Ek within active element Ei's integrating window, Wki(t)={s: active element Ek fired at time s and 0≦t−s−τki<ωki}. Let |Wki(t)| denote the number of elements in the set Wki(t). If Wki(t)=Ø, then |Wki(t)|I=0.
    A collection of input functions, {(φki: kεΓ∪Ω}, each a function of time, and each representing pulses coming from computational active elements, and input active elements. The value of the input function is computed as φki(t)=|Wki(t)|Aki(t).
    The refractory periods, transmission times and pulse widths are positive integers; and pulse amplitudes and thresholds are integers. These parameters are a function of i.e. θi(t), ri(t), Aki(t), ωki(t), τki(t). The time t is an element of the extended integers .


Input active elements that are not computational active elements have the same characteristics as computational active elements, except they have no inputs φki coming from active elements in this machine. In other words, they don't receive pulses from active elements in this machine. Input active elements are assumed to be externally firable. An external source such as the environment or an output active element from another distinct machine (I, , O) can cause an input active element to fire. The input active element can fire at any time as long as the current time minus the time the input active element last fired is greater than or equal to the input active element's refractory period.
An active element Ei can be an input active element and a computational active element. Similarly, an active element can be an output active element and a computational active element. Alternatively, when an output active element Ei is not a computational active element, where iεΔ−Ω, then Ei does not send pulses to active elements in this machine.
Some notions of the machine architecture are summarized. If gi(s)=1, this means active element Ei fired at time s. The refractory period ri is the amount of time that must elapse after active element Ei just fired before Ei can fire again. The transmission time τki is the amount of time it takes for active element Ei to find out that active element Ek has fired. The pulse amplitude Aki represents the strength of the pulse that active element Ek transmits to active element Ei after active element Ek has fired. After this pulse reaches Ei, the pulse width ωki represents how long the pulse lasts as input to active element Ei. At time s, the connection from Ek to Ei represents the triplet (Aki(s), ωki(S), τki(S)). If Aki=0, then there is no connection from active element Ek to active element E.
Refractory Period
In an embodiment, each computational element and output element has a refractory period ri, where ri>0, which is a period of time that must elapse after last sending a message before it may send another message. In other words, the refractory period, ri, is the amount of time that must elapse after active element Ei just fired and before active element E1 can fire again. In an alternative embodiment, refractory period ri could be zero, and the active element could send a message simultaneously with receiving a message and/or could handle multiple messages simultaneously.
Message Amplitude and Width
In an embodiment, each computational element and output element may be associated with a collection of message amplitudes, {Aki}k Γ∪Λ, where the first of the two indices k and i denote the active element from which the message associated with amplitude Aki is sent, and the second index denotes the active element receiving the message. The amplitude, Aki, represents the strength of the message that active element Ek transmits to active element Ei after active element Ek has fired. There are many different measures of amplitude that may be used for the amplitude of a message. For example, the amplitude of a message may be represented by the maximum value of the message or the root mean square height of the message. The same message may be sent to multiple active elements that are either computational elements or output elements, as indicated by the subscript k Γ∪Λ. However, each message may have a different amplitude Aki. Similarly, each message may be associated with its own message width, {ωki}k Γ∪Λ, sent from active element Ei to Ek, where ωki>0 for all Γ∪Λ. After a message reaches active Ei, the message width ωki represents how long the message lasts as input to active element Ei.
Threshold
In an embodiment, any given active element may be capable of sending and receiving a message, in response to receiving one or more messages, which when summed together, have an amplitude that is greater than a threshold associated with the active element. For example, if the messages are pulses, each computational and output active element, Ei, may have a threshold, θi, such that when a sum of the incoming pulses is greater than the threshold the active element fires (e.g., sends an output message). In an embodiment, when a sum of the incoming messages is lower than the threshold the active element does not fire. In another embodiment, it is possible to set the active element such that the active element fires when the sum of incoming messages is lower than the threshold; and when the sum of incoming messages is higher than the threshold, the active element does not fire.
In still another embodiment, there are two numbers α and θ where α≦θ and such that if the sum of the incoming messages lie in [α, θ], then the active element fires, but the active element does not fire if the sum lies outside of [α, θ]. In a variation of this embodiment, the active element fires if the sum of the incoming messages does not lie in [α, θ] and does not fire if the sum lies in [α, θ].
In another embodiment, the incoming pulses may be combined in other ways besides a sum. For example, if the product of the incoming pulses is greater than the threshold the active element may fire. Another alternative is for the active element to fire if the maximum of the incoming pulses is greater than the threshold. In still another alternative, the active element fires if the minimum of the incoming pulses is less than the threshold. In even another alternative if the convolution of the incoming pulses over some finite window of time is greater than the threshold, then the active element may fire.
Transmission Time
In an embodiment, each computational and output element may be associated with collection of transmission times, {τki}k Γ∪Λ, where τki>0 for all k Γ∪Λ, which are the times that it takes a message to be sent from active element Ek to active element Ei. The transmission time, τki, is the amount of time it takes for active element Ei to find out that active element Ek has fired. The transmission times, τki, may be chosen in the process of establishing the architecture.
Firing Function
In an embodiment, each active element is associated with a function of time, ψi(t), representing the time t at which active element Ei last fired. Mathematically, the function of time can be defined as ψi(t)=supremum {s R: s<t AND gi(s)=1}. The function ψi(t) always has the value of the last time that the active element fired. In general, throughout this specification the variable t is used to represent the current time, while in contrast s is used as variable of time that is not necessarily the current time.
Set of Firing Times and the Integrating Window
In an embodiment, each active element is associated with a function of time Ξki(t), which is a set of recent firing times of active element Ek that are within active element Ei's integrating window. In other words, the set of firing times Ξki(t)={s R: active element k fired at time s and 0≦t−s−τki<ωki}. The integrating window is a duration of time during which the active element accepts messages. The integrating window may also be referred to as the window of computation. Other lengths of time could be chosen for the integrating window. In contrast to ψi (t), Ξk; (t) is not a function, but a set of values. Also, where as ψi(t) has a value as long as active element Ei fired at least once, Ξki(t) does not have any values (is an empty set) if the last time that active element Ei fired is outside of the integrating window. In other words, if there are no firing times, s, that satisfy the inequality 0≦t−s−τki<ωki, then Ξki(t) is the empty set. Let |Ξki(t)| denote the number of elements in the set Ξki(t). If Ξki(t) is the empty set, then |Ξki(t)|=0. Similarly, if Ξki(t) has only one element in it then |Ξki(t)|=1.
Input Function
In an embodiment, each input element and output element may have associated with it a collection of input functions, {Øki(t)}k Γ∪Λ. Each input function may be a function of time, and may represent messages coming from computational elements and input elements. The value of input function Øki(t) is given by Øki(t)=|Ξki(t)|Aki, because each time a message from active element Ek reaches active element Ei, the amplitude of the message is added to the last message. The number of messages inside the integrating window is the same as the value of |Ξki(t)|. Since for a static machine the amplitude of the message sent from active element k to i is always the same value, Aki, therefore, the value Øki(t) equals |Ξki(t)|Aki.
Input elements that are not computational elements have the same characteristics as computational elements, except they have no input functions, Øki(t), coming from active elements in this machine. In other words, input elements do not receive messages from active elements in the machine with which the input element is associated. In an embodiment, input elements are assumed to be externally firable. An externally firable element is an element that an external element or machine can cause to fire. In an embodiment, an external source such as the environment or an output element from another distinct machine, M′(J′; E′; D′) can cause an input element to fire. An input element can fire at any time as long as this time minus the time the input element last fired is greater than or equal to the input element's refractory period.
Output Function
An output function, gi(t), may represent whether the active element fires at time t. The function gi(t) is given by




  
    
      g
      i
    
    ⁡
    
      (
      t
      )
    
  
  =
  
    {
    
      
        
          1
        
        
          
            
              if
              ⁢
              
                
              
              ⁢
              
                
                  ∑
                  
                    k
                    ∈
                    
                      Γ
                      ⁢
                      
                        
                      
                      ⁢
                      U
                      ⁢
                      
                        
                      
                      ⁢
                      Λ
                    
                  
                
                ⁢
                
                  Ø
                  ki
                
              
            
            >
            
              
                
                  θ
                  i
                
                ⁢
                
                  
                
                ⁢
                AND
                ⁢
                
                  
                
                ⁢
                t
              
              -
              
                
                  ψ
                  i
                
                ⁡
                
                  (
                  t
                  )
                
              
            
            ≥
            
              r
              i
            
          
        
      
      
        
          0
        
        
          
            otherwise
            .
          
        
      
    
  




In other words, if the sum of the input functions Øki (t) is greater than the threshold, θi, and time t is greater than or equal to the refractory period, ri, plus the time, ψi(t), that the active element last fired, then the active element Ei fires, and gi(t)=1. If gi(t0)=1, then active element Ei fired at time t0.
The fact that in an embodiment, output elements do not send messages to active elements in this machine is captured formally by the fact that the index k for the transmission times, message widths, message amplitudes, and input functions lies in Γ∪Λ and not in Δ in that embodiment.
Connections
The expression “connection” from k to i represents the triplet (Aki; ωki; τki). If Aki=0, then there is no connection from active element Ek to active element Ei. If Aki≠0, then there is a non-zero connection from active element Ek to active element Ei. In any given embodiment the active elements may have all of the above properties, only one of the above properties, or any combination of the above properties. In an embodiment, different active elements may have different combinations of the above properties. Alternatively, all of the active elements may have the same combination of the above properties.
Active Element Machine Programming Language
This section shows how to program an active element machine and how to change the machine architecture as program execution proceeds. It is helpful to define a programming language, influenced by S-expressions. There are five types of commands: Element, Connection, Fire, Program and Meta.
Syntax 1. AEM Program
In Backus-Naur form, an AEM program is defined as follows.












<AEM_program> ::= <cmd_sequence>


<cmd_sequence> ::= “” | <AEM_cmd><cmd_sequence> |


<program_def><cmd_sequence>


<AEM_cmd> ::= <element_cmd> | <fire_cmd> | <meta_cmd> |


<cnct_cmd> | <program_cmd>


<ename> ::= “” | <int> | <symbol>


<symbol> ::= <symbol_string> | (<ename> . . . <ename>)


<symbol_string> ::= “” | <char_symbol><str_tail>


<str_tail> ::= “” | <char_symbol><str_tail> | 0<str_tail> |


<pos_int><str_tail>


<char_symbol> ::= <letter> | <special_char>


<letter> ::= <lower_case> | <upper_case>








<lower_case> ::=
a | b | c | d | e | f | g | h | i | j | k | l | m |



n | o | p | q | r | s | t | u | v | w | x | y | z


<upper_case> ::=
A | B | C | D | E | F | G | H | I | J | K | L | M |



N | O | P | Q | R | S | T | U | V | W | X | Y | Z







<special_char> ::= “” | —









These rules represent the extended integers, addition and subtraction.















<int> ::= <pos_int> | <neg_int> | 0



<neg_int> ::= − <pos_int>



<pos_int> ::= <non_zero><digits>



<digits> ::= <numeral> | <numeral><digits>



<non_zero> ::= 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9



<numeral> ::= “” | <non_zero> | 0



<aint> ::= <aint> <math_op> <d> | <d> <math_op> <aint> | <d>



<math_op> ::= + | −



<d> ::= <int> | <symbol_string> | <infinitesimal>



<infinitesimal> ::= dT










Element Command.
An Element command specifies the time when an active element's values are updated or created. This command has the following Backus-Naur syntax.













<element_cmd> ::= (Element
(Time <aint>) (Name <ename>)



(Threshold <int>)



(Refractory <pos_int>) (Last <int>))









The keyword Time indicates the time value s at which the element is created or updated. In some embodiments the time value s is an extended integer. If the name symbol value is E, the keyword Name tags the name E of the active element. The keyword Threshold tags the threshold θE(s) assigned to E. Refractory indicates the refractory value rE(s). The keyword Last tags the last time fired value Ψ(s). Sometimes the time value, name value, threshold value, refractory value, or last time fired value are referred to as parameter values.
Below is an example of an element command.
(Element (Time 2) (Name H) (Threshold −3) (Refractory 2) (Last 0))
At time 2, if active element H does not exist, then it is created. Active element H has its threshold set to −3, its refractory period set to 2, and its last time fired set to 0. After time 2, active element H exists indefinitely with threshold=−3, refractory=2 until a new Element command whose name value H is executed at a later time; in this case, the Threshold, Refractory and Last values specified in the new command are updated.
Connection Command.
A Connection command creates or updates a connection from one active element to another active element. This command has the following Backus-Naur syntax.













<cnct_cmd> ::= (Connection
(Time <aint>) (From <ename>) (To



<ename>)



[(Amp <int>) (Width <pos_int>) (Delay



<pos_int>)])









The keyword Time indicates the time value s at which the connection is created or updated. In some embodiments the time value s is an extended integer. The keyword From indicates the name F of the active element that sends a pulse with these updated values. The keyword To tags the name T of the active element that receives a pulse with these updated values. The keyword Amp indicates the pulse amplitude value AFT(s) that is assigned to this connection. The keyword Width indicates the pulse width value ωFT(s). In some embodiments the pulse width value ωFT(s) is an extended integer. The keyword Delay tags the transmission time τFT(s). In some embodiments the transmission time τFT(s) is an extended integer. Sometimes the time value, from name, to name, pulse amplitude value, pulse width value, or transmission time value are referred to as parameter values.
When the AEM clock reaches time s, F and T are name values that must be the name of an element that already has been created or updated before or at time s. Not all of the connection parameters need to be specified in a connection command. If the connection does not exist beforehand and the Width and Delay values are not specified appropriately, then the amplitude is set to zero and this zero connection has no effect on the AEM computation. Observe that the connection exists indefinitely with the same parameter values until a new connection is executed at a later time between From element F and To element T.
The following is an example of a connection command.
(Connection (Time 2) (From C) (To L) (Amp −7) (Width 1) (Delay 3))
At time 2, the connection from active element C to active element L has its amplitude set to −7, its pulse width set to 1, and its transmission time set to 3.
Fire Command.
The Fire command has the following Backus-Naur syntax.
<fire_cmd>::=(Fire (Time <aint>) (Name <ename>))
The Fire command fires the active element indicated by the Name tag at the time indicated by the Time tag. Sometimes the time value and name value are referred to as parameter values of the fire command. In some embodiments, the fire command is used to fire input active elements in order to communicate program input to the active element machine. An example is (Fire (Time 3) (Name C)), which fires active element C at t=3.
Program Command.
The Program command is convenient when a sequence of commands are used repeatedly. This command combines a sequence of commands into a single command. It has the following definition syntax.












<program_def> ::= (Program <pname> [(Cmds <cmds>)] [(Args <args>)]


<cmd_sequence> )


<pname> ::= <ename>


<cmds> ::= <cmd_name> | <cmd_name><cmds>


<cmd_name> ::= Element | Connection | Fire | Meta | <pname>


<args> ::= <symbol> | <symbol><args>









The Program command has the following execution syntax.















<program_cmd> ::= (<pname> [(Cmds <cmds>)] [(Args



<args_cmd>)] )



<args_cmd> ::= <ename> | <ename><args_cmd>










The FireN program is an example of definition syntax.












(Program FireN (Args t E)









(Element (Time 0) (Name E)(Refractory l)(Threshold 1) (Last 0))



(Connection (Time 0) (From E) (To E)(Amp 2)(Width 1) (Delay 1))



(Fire (Time 1) (Name E))



(Connection (Time t+1) (From E) (To E) (Amp 0))







)









The execution of the command (FireN (Args 8 E1)) causes element E1 to fire 8 times at times 1, 2, 3, 4, 5, 6, 7, and 8 and then E1 stops firing at time=9.
Keywords Clock and dT
The keyword clock evaluates to an integer, which is the current active element machine time. clock is an instance of <ename>. If the current AEM time is 5, then the command
(Element (Time clock) (Name clock) (Threshold 1) (Refractory 1) (Last −1))
is executed as
(Element (Time 5) (Name 5) (Threshold 1) (Refractory 1) (Last −1))
Once command (Element (Time clock) (Name clock) (Threshold 1) (Refractory 1) (Last −1)) is created, then at each time step this command is executed with the current time of the AEM. If this command is in the original AEM program before the clock starts at 0, then the following sequence of elements named 0, 1, 2, . . . will be created.












(Element (Time 0) (Name 0) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 1) (Name 1) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 2) (Name 2) (Threshold 1) (Refractory 1) (Last −1))


. . .









The keyword dT represents a positive infinitesimal amount of time. If m and n are integers and 0≦m<n, then mdT<ndT. Furthermore, dT>0 and dT is less than every positive rational number. Similarly, −dT<0 and −dT is greater than every negative rational number. The purpose of dT is to prevent an inconsistency in the description of the machine architecture. For example, the use of dT helps remove the inconsistency of a To element about to receive a pulse from a From element at the same time that the connection is removed.
Meta Command.
The Meta command causes a command to execute when an element fires within a window of time. This command has the following execution syntax.












<meta_cmd> ::= (Meta (Name <ename>)[<win_time>] <AEM_cmd>)


<win_time> ::= (Window <aint> <aint>)









To understand the behavior of the Meta command, consider the execution of
(Meta (Name E) (Window l w) (C (Args t a))
where E is the name of the active element. The keyword Window tags an interval i.e. a window of time. l is an integer, which locates one of the boundary points of the window of time. Usually, w is a positive integer, so the window of time is [l, l+w]. If w is a negative integer, then the window of time is [l+w, l].
The command C executes each time that E fires during the window of time, which is either [l, l+w] or [l+w, l], depending on the sign of w. If the window of time is omitted, then command C executes at any time that element E fires. In other words, effectively l=−∞ and w=∞. Consider the example where the FireN command was defined before.















(FireN (Args 8 E1))



(Meta (Name E1) (Window 1 5) (C (Args clock a b)) )










Command C is executed 6 times with arguments dock, a, b. The firing of E1 triggers the execution of command C.
In regard to the Meta command, the following assumption is analogous to the Turing machine tape being unbounded as Turing program execution proceeds. During execution of a finite active element program, an active element can fire and due to one or more Meta commands, new elements and connections can be added to the machine. As a consequence, at any time the active element machine only has a finite number of computing elements and connections but the number of elements and connections can be unbounded as a function of time as the active element program executes.
Active Element Machine Computation
In a prior section, the firing patterns of active elements are used to represent the computation of a boolean function. In the next three definitions, firing representations, machine computation and interpretation are defined.
Firing Representation
Consider active element Ei's firing times in the interval of time W=[t1, t2]. Let s1 be the earliest firing time of Ei lying in W, and sn the latest firing time lying in W. Then Ei's firing sequence (Ei, W)=[s1, . . . , sn]={sεW: gi(s)=1} is called a firing sequence of the active element E, over the window of time W. From active elements {E1, E2, . . . , En} create the tuple ((E1, W), (E2, W), . . . , (En, W)) which is called a firing representation of the active elements {E1, E2, . . . , En} within the window of time W.
At the machine level of interpretation, firing representations (firing patterns) express the input to, the computation of, and the output of an active element machine. At a more abstract level, firing representations can represent an input symbol, an output symbol, a sequence of symbols, a spatio-temporal pattern, a number, or even a family of program instructions for another computing machine.
Sequence of Firing Representations.
Let W1, . . . , Wn be a sequence of time intervals. Let (, W1)=((E1, W1), (E2, W1), . . . , (En, W1)) be a firing representation of active elements ={E1, . . . , En} over the interval W1. In general, let (E, Wk)=((E1, Wk), (E2, Wk), . . . (En, Wk)) be a firing representation over the interval of time Wk. From these, a sequence of firing representations, [(, W1), (, W2), . . . , (, Wn)] is created.
Machine Computation
Let [(, W1), (, W2), . . . (, Wn)] be a sequence of firing representations. [(, S1), (, S2), . . . , (, Sm)] is some other sequence of firing representations. Suppose machine architecture (I, E, O) has input active elements/fire with the pattern [(, S1), (, S2), . . . , (, Sm)] and consequently 's output active elements O fire according to [(, W1), (, W2), . . . , (, Wn)]. In this case, the machine M computes [(, W1), (, W2), . . . , (, Wn)] from [(, S1), (, S2), . . . , (, Sm)].
An active element machine is an interpretation between two sequences of firing representations if the machine computes the output sequence of firing representations from the input sequence of firing representations.
Concurrent Generation of AEM Commands
This section shows embodiments pertaining to two or more commands about to set parameter values of the same connection or same element at the same time. Consider two or more connection commands, connecting the same active elements, that are generated and scheduled to execute at the same time.












(Connection (Time t) (From A) (To B) (Amp 2) (Width 1) (Delay 1))


(Connection (Time t) (From A) (To B) (Amp −4) (Width 3) (Delay 7))









Then the simultaneous execution of these two commands can be handled by defining the outcome to be equivalent to the execution of only one connection command where the respective amplitudes, widths and transmission times are averaged.
(Connection (Time t) (From A) (To B) (Amp −1) (Width 2) (Delay 4))
In the general case, for n connection commands












(Connection (Time t) (From A) (To B) (Amp a1) (Width w1) (Delay s1))


(Connection (Time t) (From A) (To B) (Amp a2) (Width w2) (Delay s2))


. . .


(Connection (Time t) (From A) (To B) (Amp an)(Width wn)(Delay sn))









resolve these to the execution of one connection command

(Connection (Time t) (From A) (To B) (Amp a) (Width w) (Delay s))

where a, w and s are defined based on the application. These embodiments can be implemented in active element machine software, AEM hardware or a combination of AEM hardware and software.

For some embodiments of the AEM, averaging the respective amplitudes, widths and transmission times is useful.

a=(a1+a2+ . . . +an)/n 

w=(w1+w2+ . . . +wn)/n 

s=(s1+s2+ . . . +sn)/n 

For embodiments that use averaging, they can be implemented in active element machine software, AEM hardware or a combination of AEM hardware and software.

For some embodiments, when there is noisy environmental data fed to the input elements and amplitudes, widths and transmission times are evolved and mutated, extremely large (in absolute value) amplitudes, widths and transmission times can arise that skew an average function. In these embodiments, computing the median of the amplitudes, widths and delays provides a simple method to address skewed amplitude, width and transmission time values.

a=median(a1,a2, . . . ,an)

w=median(w1,w2, . . . ,wn)

s=median(s1,s2, . . . ,sn)

Another alternative embodiment adds the parameter values.

a=a1+a2+ . . . +an 

w=w1+w2+ . . . +wn 

s=s1+s2+ . . . +sn 

Similarly, consider when two or more element commands—that all specify the same active element E—are generated and scheduled to execute at the same time.












(Element (Time t) (Name E) (Threshold h1) (Refractory r1) (Last s1))


(Element (Time t) (Name E) (Threshold h2) (Refractory r2) (Last s2))


. . .


(Element (Time t) (Name E) (Threshold hn) (Refractory rn) (Last sn))









resolve these to the execution of one element command,

(Element (Time t) (Name E) (Threshold h) (Refractory r) (Last s))

where h, r and s are defined based on the application. Similar to the connection command, for theoretical studies of the AEM, the threshold, refractory and last time fired values can be averaged.

h=(h1+h2+ . . . +hn)/n 

r=(r1+r2+ . . . +rn)/n 

s=(s1+s2+ . . . +sn)/n 

In autonomous embodiments, where evolution of parameter values occurs, the median can also help address skewed values in the element commands.

h=median(h1,h2, . . . hn)

r=median(r1,r2, . . . rn)

s=median(s1,s2, . . . sn)

Another alternative is to add the parameter values.

h=h1+h2+ . . . +hn 

r=r1+r2+ . . . +rn 

s=s1+s2+ . . . +sn 

Rules A, B, and C resolve concurrencies pertaining to the Fire, Meta and Program commands. Rule A. If two or more Fire commands attempt to fire element E at time t, then element E is fired just once at time t.
Rule B. Only one Meta command can be triggered by the firing of an active element. If a new Meta command is created and it happens to be triggered by the same element E as a prior Meta command, then the old Meta command is removed and the new Meta command is triggered by element E.
Rule C. If a Program command is called by a Meta command, then the Program's internal Element, Connection, Fire and Meta commands follow the previous concurrency rules defined. If a Program command exists within a Program command, then these rules are followed recursively on the nested Program command.
An AEM Program Computes a Ramsey Number
This section shows how to compute a Ramsey number with an AEM program. Ramsey theory can be intuitively described as structure which is preserved under finite decomposition. Applications of Ramsey theory include computer science, including lower bounds for parallel sorting, game theory and information theory. Progress on determining the basic Ramsey numbers r(k, l) has been slow. For positive integers k and l, r(k, l) denotes the least integer n such that if the edges of the complete graph Kn are 2-colored with colors red and blue, then there always exists a complete subgraph Kk containing all red edges or there exists a subgraph Kl containing all blue edges. To put our slow progress into perspective, arguably the best combinatorist of the 20th century, Paul Erdos asks us to imagine an alien force, vastly more powerful than us, landing on Earth and demanding the value of r(5, 5) or they will destroy our planet. In this case, Erdos claims that we should marshal all our computers and all our mathematicians and attempt to find the value. But suppose instead that they ask for r(6, 6). For r(6, 6), Erdos believes that we should attempt to destroy the aliens.
Theorem R. The Standard Finite Ramsey Theorem.
For any positive integers m, k, n, there is a least integer N(m, k, n) with the following property: no matter how we color each of the n-element subsets of S={1, 2, . . . , N} with one of k colors, there exists a subset Y of S with at least m elements, such that all n-element subsets of Y have the same color.
When G and H are simple graphs, there is a special case of theorem R. Define the Ramsey number r(G, H) to be the smallest N such that if the complete graph KN is colored red and blue, either the red subgraph contains G or the blue subgraph contains H. (A simple graph is an unweighted, undirected graph containing no graph loops or multiple edges. In a simple graph, the edges of the graph form a set and each edge is a pair of distinct vertices.) In [10], S. A. Burr proves that determining r(G, H) is an NP-hard problem.
An AEM program is shown that solves a special case of Theorem 3. Similar embodiments can compute larger Ramsey numbers. Consider the Ramsey number where each edge of the complete graph K6 is colored red or blue. Then there is always at least one triangle, which contains only blue edges or only red edges. In terms of the standard Ramsey theorem, this is the special case N(3, 2, 2) where n=2 since we color edges (i.e. 2-element subsets); k=2 since we use two colors; and m=3 since the goal is to find a red or blue triangle. To demonstrate how an AEM program can be designed to compute N(3, 2, 2)=6, an AEM program is shown that verifies N(3, 2, 2)>5.
The symbols B and R represent blue and red, respectively. Indices are placed on B and R to denote active elements that correspond to the K5 graph geometry. The indices come from graph geometry. Let E={{1,2},{1,3},{1,4},{1,5}, {2,3},{2,4},{2,5}, {3,4},{3,5},{4,5}} denote the edge set of K5.
The triangle set T={{1,2,3}, {1,2,4}, {1,2,5}, {1,3,4}, {1,3,5}, {1,4,5}, {2,3,4}, {2,3,5}, {2,4,5}, {3,4,5}}. Each edge is colored red or blue. Thus, the red edges are {{1,2}, {1,5}, {2,3}, {3,4}, {4,5}} and the blue edges are {{1,3},{1,4},{2,4},{2,5},{3,5}}. Number each group of AEM commands for K5, based on the group's purpose. This is useful because these groups will be used when describing the computation for K6.
1. The elements representing red and blue edges are established as follows.












(Element (Time 0) (Name R_12) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name R_15) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name R_23) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name R_34) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name R_45) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name B_13) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name B_14) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name B_24) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name B_25) (Threshold 1) (Refractory 1) (Last −1))


(Element (Time 0) (Name B_35) (Threshold 1) (Refractory 1) (Last −1))









2. Fire element R—24 if edge {j, k} is red.















(Fire (Time 0) (Name R_12))



(Fire (Time 0) (Name R_15))



(Fire (Time 0) (Name R_23))



(Fire (Time 0) (Name R_34))



(Fire (Time 0) (Name R_45))










Fire element B_jk if edge {j, k} is blue where j<k.
















(Fire (Time 0) (Name B_13))



(Fire (Time 0) (Name B_14))



(Fire (Time 0) (Name B_24))



(Fire (Time 0) (Name B_25))



(Fire (Time 0) (Name B_35))










3. The following Meta commands cause these elements to keep firing after they have fired once.















(Meta (Name R_jk) (Window 0 1)



(Connection (Time 0) (From R_jk) (To R_jk) (Amp 2) (Width 1)



(Delay 1)))



(Meta (Name B_jk) (Window 0 1)



(Connection (Time 0) (From B_jk) (To B_jk) (Amp 2) (Width 1)



(Delay 1)))










4. To determine if a blue triangle exists on vertices {i, j, k}, where {i, j, k} ranges over T, three connections are created for each potential blue triangle.















(Connection (Time 0) (From B_ij) (To B_ijk) (Amp 2) (Width 1)



(Delay 1))



(Connection (Time 0) (From B_jk) (To B_ijk) (Amp 2) (Width 1)



(Delay 1))



(Connection (Time 0) (From B_ik) (To B_ijk) (Amp 2) (Width 1)



(Delay 1))










5. To determine if a red triangle exists on vertex set {i, j, k}, where {i, j, k} ranges over T, three connections are created for each potential red triangle.















(Connection (Time 0) (From R_ij) (To R_ijk) (Amp 2) (Width 1)



(Delay 1))



(Connection (Time 0) (From R_jk) (To R_ijk) (Amp 2) (Width 1)



(Delay 1))



(Connection (Time 0) (From R_ik) (To R_ijk) (Amp 2) (Width 1)



(Delay 1))










6. For each vertex set {i, j, k} in T, the following elements are created.












(Element (Time 0) (Name R_ijk) (Threshold 5) (Refractory 1) (Last −1))


(Element (Time 0) (Name B_ijk) (Threshold 5) (Refractory 1) (Last −1))









Because the threshold is 5, the element R_ijk only fires when all three elements R_ij, R_jk, R_ik fired one unit of time ago. Likewise, the element B_jjk only fires when all three elements B_jj, B_jk, B_jk fired one unit of time ago. From this, we observe that as of clock=3 i.e. 4 time steps, this AEM program determines that N(3, 2, 2)>5. This AEM computation uses




  
    
      
      E
      
    
    +
    
      2
      ⁢
      
        
        T
        
      
    
  
  =
  
    
      
        
          5
          !
        
        
          
            2
            !
          
          ⁢
          
            3
            !
          
        
      
      +
      
        2
        ⁢
        
          
            5
            !
          
          
            
              3
              !
            
            ⁢
            
              2
              !
            
          
        
      
    
    =
    
      30
      ⁢
      
        
      
      ⁢
      active
      ⁢
      
        
      
      ⁢
      
        elements
        .
      
    
  




Further, this AEM program creates and uses 3|T|+3|T|+|E|=70 connections.

For K6, the edge set E={{1, 2}, {1, 3}, {1, 4}, {1, 5}, ≡1, 6}, {2, 3}, {2, 4}, {2, 5}, {2, 6}, {3, 4}, {3, 5}, {3, 6}, {4, 5}, {4, 6}, {5, 6}}. The triangle set T={{1, 2, 3}, {1, 2, 4}, {1, 2, 5}, {1, 2, 6}, {1, 3, 4}, {1, 3, 5}, {1, 3, 6}, {1, 4, 5}, {1, 4, 6}, {1, 5, 6}, {2, 3, 4}, {2, 3, 5}, {2, 3, 6}, {2, 4, 5}, {2, 4, 6}, {2, 5, 6}, {3, 4, 5}, {3, 4, 6}, {3, 5, 6}, {4, 5, 6}1. For each 2-coloring of E, each edge is colored red or blue. There are 2|E|2-colorings of E. For this graph,




  
    
    E
    
  
  =
  
    
      6
      !
    
    
      
        2
        !
      
      ⁢
      
        4
        !
      
    
  




To build a similar AEM program, the commands in groups 1 and 2 range over every possible 2-coloring of E. The remaining groups 3, 4, 5 and 6 are the same based on the AEM commands created in groups 1 and 2 for each particular 2-coloring.
This AEM program verifies that every 2-coloring of E contains at least one red triangle or one blue triangle i.e. N(3, 2, 2)=6. There are no optimizations using graph isomorphisms made here. If an AEM language construct is used for generating all active elements for each 2-coloring of E at time zero, then the resulting AEM program can determine the answer in 5 time steps. One more time step is needed, 215 additional connections and one additional element to verify that every one of the 215 AEM programs is indicating that it found a red or blue triangle. This AEM program—that determines the answer in 5 time steps—uses 2|E|(|E|+2|T|)+1 active elements and 2|E|(3|T|+3|T|+|E|+1) connections, where |E|=15 and |T|=20. Some graph problems are related to the computation of Ramsey numbers.
A couple common graph problems are the traveling salesman problem and the traveling purchaser problem. (See <http://en.wikipedia.org/wiki/Traveling_salesman_problem> and <http://en.wikipedia.org/wiki/Traveling_purchaser_problem>.)
The traveling salesman problem can be expressed as a list of cities and their pairwise distances. The solution of the problem consists of finding the shortest possible tour that visits each city exactly once. Methods of solving the traveling salesman problem are useful for FedEx and other shipping companies where fuel costs and other shipping costs are substantial.
The traveling salesman problem has applications in planning, logistics, and the manufacture of microchips. Slightly modified, the traveling salesman problem appears as a sub-problem in many areas, such as DNA sequencing. In these applications, the concept city represents, for example, customers, soldering points, or DNA fragments, and the concept distance represents travelling times or cost, or a similarity measure between DNA fragments.
In embodiments similar to the computation of Ramsey numbers, the cities (customers, soldering points or DAN fragments) correspond to active elements and there is one connection between two cities for a possible tour that is being explored. In some embodiments, the thresholds of the two elements are used to account for the distance between the cities while exploring a path for a shortest possible tour. In other embodiments, the different distances between cities can be accounted for by using time.
Multiplying Numbers with an Active Element Machine
This section shows how to multiply numbers with an active element machine. Elements Y0, Y1, Y2, Y3 denote a four bit number and elements Z0, Z1 Z2, Z3 denote a four bit number. The corresponding bit values are y0, y1, y2, y3 and z0, z1, z2, z3. The multiplication of y3 y2 y1 y0*z3 z2 z1 z0 is shown in Table 13. An active element program is constructed based on Table 13.
The following commands set up elements and connections to perform a four bit multiplication of y3 y2 y1 y0*z3 z2 z1 z0 where the result of this multiplication e7 e6 e5 e4 e3 e2 e1 e0 is stored in elements E7, E6, E5, E4, E3, E2, E1 and E0. The computation is encoded by the elements S_jk corresponds to the product yj zk where S_jk fires if and only if yj=1 and zk=1. The elements C_jk help determine the value of ei represented by element Ei where j+k=
First, two useful program commands are defined.












(Program set_element (Args s xk theta r L)









(Element (Time s−2dT) (Name xk) (Threshold theta) (Refractory r)



(Last L))







)


(Program set_connection (Args s f xk a w tau)









(Connection (Time s−dT) (From f) (To xk) (Amp a) (Width w)



(Delay tau))







)









The firing activity of element E0 expresses the value of e0. The elements and connections for the product y0 z0 which determine the value of e0 are determined by the following three program commands.















(set_element s E0 3 1 s−2)



(set_connection s Y0 E0 2 1 1)



(set_connection s Z0 E0 2 1 1)










Table 14 shows the amplitude and threshold used to compute the value of e0. Table 15 shows the firing patterns for elements S10 and S0l representing the value of products y1 z0 and y0 z1. Table 16 shows the amplitudes from elements S10 and S0l to elements C0l and C11 and the thresholds of C01 and C11. Table 17 shows the amplitudes from elements C0l and C11 to element E1 and the threshold of E1. The firing activity of element E1 expresses the value of e1. Below are active element machine commands that express the parameter values of these elements and connections shown in table 14, table 15, table 16 and table 17.















(set_element s S_10 3 1 s−2)



(set_connection s Y1 S_10 2 1 1)



(set_connection s Z0 S_10 2 1 1)



(set_element s S_01 3 1 s−2)



(set_connection s Y0 S_01 2 1 1)



(set_connection s Z1 S_01 2 1 1)



(set_element s C_01 1 1 s−2)



(set_element s C_11 3 1 s−2)



(set_connection s S_10 C_01 2 1 1)



(set_connection s S_10 C_11 2 1 1)



(set_connection s S_01 C_01 2 1 1)



(set_connection s S_01 C_11 2 1 1)



(set_element s E1 1 1 s−2)



(set_connection s C_01 E1 2 1 1)



(set_connection s C_11 E1 −2 1 1)










Table 18 shows the firing patterns for elements S20, S11, S02 and C11. Table 19 shows the amplitudes from elements S20, S11 S02, C11 to elements C02, C12, C22 C32 and the thresholds of C02, C12, C22 and C32. Table 20 shows the amplitudes from elements C02, C12, C22, C32 to elements P02, P12, P22 and the thresholds of elements P02, P12, P22. Table 21 shows the amplitude and threshold used to compute the value of e2. The firing activity of element E2 expresses the value of e2. Below are active element machine commands that express the parameter values of the elements and connections indicated in table 18, table 19, table 20 and table 21.















(set_element s S_20 3 1 s−2)



(set_connection s Y2 S_20 2 1 1)



(set_connection s Z0 S_20 2 1 1)



(set_element s S_11 3 1 s−2)



(set_connection s Y1 S_11 2 1 1)



(set_connection s Z1 S_11 2 1 1)



(set_element s S_02 3 1 s−2)



(set_connection s Y0 S_02 2 1 1)



(set_connection s Z2 S_02 2 1 1)



(set_element s C_02 1 1 s−2)



(set_element s C_12 3 1 s−2)



(set_element s C_22 5 1 s−2)



(set_element s C_32 7 1 s−2)



(set_connection s S_20 C_02 2 1 1)



(set_connection s S_20 C_12 2 1 1)



(set_connection s S_20 C_22 2 1 1)



(set_connection s S_20 C_32 2 1 1)



(set_connection s S_11 C_02 2 1 1)



(set_connection s S_11 C_12 2 1 1)



(set_connection s S_11 C_22 2 1 1)



(set_connection s S_11 C_32 2 1 1)



(set_connection s S_02 C_02 2 1 1)



(set_connection s S_02 C_12 2 1 1)



(set_connection s S_02 C_22 2 1 1)



(set_connection s S_02 C_32 2 1 1)



(set_connection s C_11 C_02 2 1 1)



(set_connection s C_11 C_12 2 1 1)



(set_connection s C_11 C_22 2 1 1)



(set_connection s C_11 C_32 2 1 1)



(set_element s P_02 1 1 s−2)



(set_element s P_12 1 1 s−2)



(set_element s P_22 7 1 s−2)



(set_connection s C_02 P_02 2 1 1)



(set_connection s C_02 P_12 0 1 1)



(set_connection s C_02 P_22 2 1 1)



(set_connection s C_12 P_02 −2 1 1)



(set_connection s C_12 P_12 2 1 1)



(set_connection s C_12 P_22 2 1 1)



(set_connection s C_22 P_02 2 1 1)



(set_connection s C_22 P_12 2 1 1)



(set_connection s C_22 P_22 2 1 1)



(set_connection s C_32 P_02 −2 1 1)



(set_connection s C_32 P_12 −4 1 1)



(set_connection s C_32 P_22 2 1 1)



(set_element s E2 1 1 s−2)



(set_connection s P_02 E2 2 1 1)










Table 22 shows the firing patterns for elements S30, S21, S12, S03, P12 representing the value of products y3 z0, y2 z1, y1 z2 and y0 z3 and the carry value. Table 23 shows the amplitudes from elements S30, S21, S12 and S03 to elements C03, C13, C23, C33, and C43. Table 24 shows the amplitudes from elements C03, C13, C23, C33, and C43 to elements P03, P13, P23 and the thresholds of elements P03, P13, P23. Table 25 shows the amplitude and threshold used to compute the value of e3. The firing activity of element E3 expresses the value of e3. Below are active element machine commands that express the parameter values shown in table 22, table 23, table 24 and table 25.















(set_element s S_30 3 1 s−2)



(set_connection s Y3 S_30 2 1 1)



(set_connection s Z0 S_30 2 1 1)



(set_element s S_21 3 1 s−2)



(set_connection s Y2 S_21 2 1 1)



(set_connection s Z1 S_21 2 1 1)



(set_element s S_12 3 1 s−2)



(set_connection s Y1 S_12 2 1 1)



(set_connection s Z2 S_12 2 1 1)



(set_element s S_03 3 1 s−2)



(set_connection s Y0 S_03 2 1 1)



(set_connection s Z3 S_03 2 1 1)



(set_element s C_03 1 1 s−2)



(set_element s C_13 3 1 s−2)



(set_element s C_23 5 1 s−2)



(set_element s C_33 7 1 s−2)



(set_element s C_43 9 1 s−2)



(set_connection s S_30 C_03 2 1 1)



(set_connection s S_30 C_13 2 1 1)



(set_connection s S_30 C_23 2 1 1)



(set_connection s S_30 C_33 2 1 1)



(set_connection s S_30 C_43 2 1 1)



(set_connection s S_21 C_03 2 1 1)



(set_connection s S_21 C_13 2 1 1)



(set_connection s S_21 C_23 2 1 1)



(set_connection s S_21 C_33 2 1 1)



(set_connection s S_21 C_43 2 1 1)



(set_connection s S_12 C_03 2 1 1)



(set_connection s S_12 C_13 2 1 1)



(set_connection s S_12 C_23 2 1 1)



(set_connection s S_12 C_33 2 1 1)



(set_connection s S_12 C_43 2 1 1)



(set_connection s S_03 C_03 2 1 1)



(set_connection s S_03 C_13 2 1 1)



(set_connection s S_03 C_23 2 1 1)



(set_connection s S_03 C_33 2 1 1)



(set_connection s S_03 C_43 2 1 1)



(set_connection s P_12 C_03 2 1 1)



(set_connection s P_12 C_13 2 1 1)



(set_connection s P_12 C_23 2 1 1)



(set_connection s P_12 C_33 2 1 1)



(set_connection s P_12 C_43 2 1 1)



(set_element s P_03 1 1 s−2)



(set_element s P_13 1 1 s−2)



(set_element s P_23 7 1 s−2)



(set_connection s C_03 P_03 2 1 1)



(set_connection s C_03 P_13 0 1 1)



(set_connection s C_03 P_23 2 1 1)



(set_connection s C_13 P_03 −2 1 1)



(set_connection s C_13 P_13 2 1 1)



(set_connection s C_13 P_23 2 1 1)



(set_connection s C_23 P_03 2 1 1)



(set_connection s C_23 P_13 2 1 1)



(set_connection s C_23 P_23 2 1 1)



(set_connection s C_33 P_03 −2 1 1)



(set_connection s C_33 P_13 −4 1 1)



(set_connection s C_33 P_23 2 1 1)



(set_connection s C_43 P_03 2 1 1)



(set_connection s C_43 P_13 0 1 1)



(set_connection s C_43 P_23 2 1 1)



(set_element s E3 1 1 s−2)



(set_connection s P_03 E3 2 1 1)










Table 26 shows the firing patterns for elements S31, S22, S13, P13, P22. Table 27 shows the amplitudes from elements S31, S22, S13, P13, P22 to elements C04, C14, C24, C34, C44 and the thresholds of C04, C14, C24, C34 and C44. Table 28 shows the amplitudes from elements C04, C14, C24, C34, and C44 to elements P04, P14, P24 and the thresholds of elements P04, P14, P24. Table 29 shows the amplitude and threshold used to compute the value of e4. The firing activity of element E4 expresses the value of e4. Below are active element machine commands that express the parameter values shown in table 26, table 27, table 28 and table 29.















(set_element s S_31 3 1 s−2)



(set_connection s Y3 S_31 2 1 1)



(set_connection s Z1 S_31 2 1 1)



(set_element s S_22 3 1 s−2)



(set_connection s Y2 S_22 2 1 1)



(set_connection s Z2 S_22 2 1 1)



(set_element s S_13 3 1 s−2)



(set_connection s Y1 S_13 2 1 1)



(set_connection s Z2 S_13 2 1 1)



(set_element s C_04 1 1 s−2 )



(set_element s C_14 3 1 s−2 )



(set_element s C_24 5 1 s−2 )



(set_element s C_34 7 1 s−2 )



(set_element s C_44 9 1 s−2 )



(set_connection s S_31 C_04 2 1 1)



(set_connection s S_31 C_14 2 1 1)



(set_connection s S_31 C_24 2 1 1)



(set_connection s S_31 C_34 2 1 1)



(set_connection s S_31 C_44 2 1 1)



(set_connection s S_22 C_04 2 1 1)



(set_connection s S_22 C_14 2 1 1)



(set_connection s S_22 C_24 2 1 1)



(set_connection s S_22 C_34 2 1 1)



(set_connection s S_22 C_44 2 1 1)



(set_connection s S_13 C_04 2 1 1)



(set_connection s S_13 C_14 2 1 1)



(set_connection s S_13 C_24 2 1 1)



(set_connection s S_13 C_34 2 1 1)



(set_connection s S_13 C_44 2 1 1)



(set_connection s P_22 C_04 2 1 1)



(set_connection s P_22 C_14 2 1 1)



(set_connection s P_22 C_24 2 1 1)



(set_connection s P_22 C_34 2 1 1)



(set_connection s P_22 C_44 2 1 1)



(set_connection s P_13 C_04 2 1 1)



(set_connection s P_13 C_14 2 1 1)



(set_connection s P_13 C_24 2 1 1)



(set_connection s P_13 C_34 2 1 1)



(set_connection s P_13 C_44 2 1 1)



(set_element s P_04 1 1 s−2)



(set_element s P_14 1 1 s−2)



(set_element s P_24 7 1 s−2)



(set_connection s C_04 P_04 2 1 1)



(set_connection s C_04 P_14 0 1 1)



(set_connection s C_04 P_24 2 1 1)



(set_connection s C_14 P_04 −2 1 1)



(set_connection s C_14 P_14 2 1 1)



(set_connection s C_14 P_24 2 1 1)



(set_connection s C_24 P_04 2 1 1)



(set_connection s C_24 P_14 2 1 1)



(set_connection s C_24 P_24 2 1 1)



(set_connection s C_34 P_04 −2 1 1)



(set_connection s C_34 P_14 −4 1 1)



(set_connection s C_34 P_24 2 1 1)



(set_connection s C_44 P_04 2 1 1)



(set_connection s C_44 P_14 0 1 1)



(set_connection s C_44 P_24 2 1 1)



(set_element s E4 1 1 s−2)



(set_connection s P_04 E4 2 1 1)










Table 30 shows the firing patterns for elements S32, S23, P14, P23. Table 31 shows the amplitudes from elements S32, S23, P14, P23 to elements C05, C15, C25, C35 and the thresholds of C05, C15, C25, C35. Table 32 shows the amplitudes from elements C05, C15, C25, C35 to elements P05, P15, P25 and the thresholds of elements P05, P15, P25. Table 33 shows the amplitude and threshold used to compute the value of e5. The firing activity of element E5 expresses the value of e5. Below are active element machine commands that express the parameter values shown in table 30, table 31, table 32 and table 33.















(set_element s S_32 3 1 s−2)



(set_connection s Y3 S_32 2 1 1)



(set_connection s Z2 S_32 2 1 1)



(set_element s S_23 3 1 s−2)



(set_connection s Y2 S_23 2 1 1)



(set_connection s Z3 S_23 2 1 1)



(set_element s C_05 1 1 s−2)



(set_element s C_15 3 1 s−2)



(set_element s C_25 5 1 s−2)



(set_element s C_35 7 1 s−2)



(set_connection s S_32 C_05 2 1 1)



(set_connection s S_32 C_15 2 1 1)



(set_connection s S_32 C_25 2 1 1)



(set_connection s S_32 C_35 2 1 1)



(set_connection s S_23 C_05 2 1 1)



(set_connection s S_23 C_15 2 1 1)



(set_connection s S_23 C_25 2 1 1)



(set_connection s S_23 C_35 2 1 1)



(set_connection s P_14 C_05 2 1 1)



(set_connection s P_14 C_15 2 1 1)



(set_connection s P_14 C_25 2 1 1)



(set_connection s P_14 C_35 2 1 1)



(set_connection s P_23 C_05 2 1 1)



(set_connection s P_23 C_15 2 1 1)



(set_connection s P_23 C_25 2 1 1)



(set_connection s P_23 C_35 2 1 1)



(set_element s P_05 1 1 s−2)



(set_element s P_15 1 1 s−2)



(set_element s P_25 7 1 s−2)



(set_connection s C_05 P_05 2 1 1)



(set_connection s C_05 P_15 0 1 1)



(set_connection s C_05 P_25 2 1 1)



(set_connection s C_15 P_05 −2 1 1)



(set_connection s C_15 P_15 2 1 1)



(set_connection s C_15 P_25 2 1 1)



(set_connection s C_25 P_05 2 1 1)



(set_connection s C_25 P_15 2 1 1)



(set_connection s C_25 P_25 2 1 1)



(set_connection s C_35 P_05 −2 1 1)



(set_connection s C_35 P_15 −4 1 1)



(set_connection s C_35 P_25 2 1 1)



(set_element s E5 1 1 s−2)



(set_connection s P_05 E5 2 1 1)










Table 34 shows the firing patterns for elements S33, P159 P24. Table 35 shows the amplitudes from elements S33, P15, P24 to elements C06, C16, C26 and the thresholds of C06, C16, C26. Table 36 shows the amplitudes from elements C06, C16, C26 to elements P06, P16 and the thresholds of elements P06, P16. Table 37 shows the amplitude of the connection from element P06 to element E6 and the threshold of E6. The firing activity of E6 expresses the value of e6. Below are active element machine commands that express the parameter values shown in table 34, table 35, table 36 and table 37.















(set_element s S_33 3 1 s−2)



(set_connection s Y3 S_33 2 1 1)



(set_connection s Z3 S_33 2 1 1)



(set_element s C_06 1 1 s−2)



(set_element s C_16 3 1 s−2)



(set_element s C_26 5 1 s−2)



(set_connection s S_33 C_06 2 1 1)



(set_connection s S_33 C_16 2 1 1)



(set_connection s S_33 C_26 2 1 1)



(set_connection s P_15 C_06 2 1 1)



(set_connection s P_15 C_16 2 1 1)



(set_connection s P_15 C_26 2 1 1)



(set_connection s P_24 C_06 2 1 1)



(set_connection s P_24 C_16 2 1 1)



(set_connection s P_24 C_26 2 1 1)



(set_element s P_06 1 1 s−2 )



(set_element s P_16 1 1 s−2 )



(set_connection s C_06 P_06 2 1 1)



(set_connection s C_06 P_16 0 1 1)



(set_connection s C_16 P_06 −2 1 1)



(set_connection s C_16 P_16 2 1 1)



(set_connection s C_26 P_06 2 1 1)



(set_connection s C_26 P_16 2 1 1)



(set_element s E6 1 1 s−2)



(set_connection s P_06 E6 2 1 1)










The firing activity of element E7 represents bit e7. When element P16 is firing, this means that there is a carry so E7 should fire. The following commands accomplish this.















(set_element s E7 1 1 s−2)



(set_connection s P_16 E7 2 1 1)










Table 38 shows how the active element machine commands were designed to compute 1110*0111. Suppose that the AEM commands from the previous sections are called with s=2. Then y0=0. y1=1. y2=1. y3=1. z0=1. z1=1. z2=1. z3=0. Thus, fire input elements Y1, Y2 and Y3 at time 2. Similarly, fire input elements Z0, Z1 and Z2 at time 2.















(set_element 2 Y1 1 1 0)



(set_connection 2 Y1 Y1 2 1+dT 1)



(fire (Time 2) (Name Y1))



(set_element 2 Y2 1 1 0)



(set_connection 2 Y2 Y2 2 1+dT 1)



(fire (Time 2) (Name Y2))



(set_element 2 Y3 1 1 0)



(set_connection 2 Y3 Y3 2 1+dT 1)



(fire (Time 2) (Name Y3))



(set_element 2 Z0 1 1 0)



(set_connection 2 Z0 Z0 2 1+dT 1)



(fire (Time 2) (Name Z0))



(set_element 2 Z1 1 1 0)



(set_connection 2 Z1 Z1 2 1+dT 1)



(fire (Time 2) (Name Z1))



(set_element 2 Z2 1 1 0)



(set_connection 2 Z2 Z2 2 1+dT 1)



(fire (Time 2) (Name Z2))










Element E0 never fires because E0 only receives a pulse of amplitude 2 from Z0 and has threshold 3. The fact that E0 never fires represents that e0=0.
In regard to the value of e1, element S10 fires at time 3 because Y1 and Z0 fire at time 2 and S10 has a threshold of 3 and receives a pulse of amplitude 2 from Y1, and Z0. The following commands set these values.















(set_element s S_10 3 1 s−2)



(set_connection s Y1 S_10 2 1 1)



(set_connection s Z0 S_10 2 1 1)










Element S0l does not fire at time 3 because it only receives a pulse of amplitude 2 from element Z1 and has threshold 3. The firing of S10 at time 3 causes C01 to fire at time 4 because C01's threshold is 1. The following commands set up these element and connection values.















(set_element s C_01 1 1 s−2)



(set_connection s S_10 C_01 2 1 1)










The commands















(set_element s E1 1 1 s−2)



(set_connection s C_01 E1 2 1 1)










cause E1 to fire at time 5 and E1 continues to fire indefinitely because the input elements Y1, Y2, Y3, Z0, Z1 and Z2 continue to fire at time steps 3, 4, 5, 6, 7, 8, . . . . The firing of element E1 indicates that e1=1.

In regard to the value of e2, since elements Y1 and Z1 fire at time 2, element S11 fires at time 3. Since elements Y2 and Z0 fire at time 2, element S20 also fires at time 3. From the following commands















(set_element 2 C_02 1 1 0)



(set_element 2 C_12 3 1 0)



(set_connection 2 S_20 C_02 2 1 1)



(set_connection 2 S_20 C_12 2 1 1)



(set_connection 2 S_11 C_02 2 1 1)



(set_connection 2 S_11 C_12 2 1 1)










then elements C02 and C12 fire at time 4.

Element P12 fires at time 5 because of the commands















(set_element 2 P_12 1 1 0)



(set_connection 2 C_12 P_12 2 1 1)



(set_connection 2 C_02 P_12 0 1 1)










Observe that element P02 does not fire because C12 sends a pulse with amplitude −2 and C02 sends a pulse with amplitude 2 and element P02 has threshold 1 as a consequence of command
(set_element 2 P—02 1 1 0).
Since P02 does not fire, element E2 does not fire as it threshold is 1 and the only connection to element E2 is from P02: (set_connection 2 P—02 E2 2 1 1). Since element E2 does not fire, this indicates that e2=0.
In regard to the value of e3, since elements Y3 and Z0 fire at time 2, element S30 fires at time 3. Since elements Y2 and Z1 fire at time 2, element S21 fires at time 3. Since elements Y1 and Z2 fire at time 2, element S12 fires at time 3. S03 does not fire. From the following commands















(set_element 2 C_03 1 1 0)



(set_element 2 C_13 3 1 0)



(set_element 2 C_23 5 1 0)



(set_element 2 C_33 7 1 0)



(set_connection 2 S_30 C_03 2 1 1)



(set_connection 2 S_30 C_13 2 1 1)



(set_connection 2 S_30 C_23 2 1 1)



(set_connection 2 S_30 C_33 2 1 1)



(set_connection 2 S_21 C_03 2 1 1)



(set_connection 2 S_21 C_13 2 1 1)



(set_connection 2 S_21 C_23 2 1 1)



(set_connection 2 S_21 C_33 2 1 1)



(set_connection 2 S_12 C_03 2 1 1)



(set_connection 2 S_12 C_13 2 1 1)



(set_connection 2 S_12 C_23 2 1 1)



(set_connection 2 S_12 C_33 2 1 1)



(set_connection 2 P_12 C_03 2 1 1)



(set_connection 2 P_12 C_13 2 1 1)



(set_connection 2 P_12 C_23 2 1 1)



(set_connection 2 P_12 C_33 2 1 1)










then elements C03, C13, C23 fire at time 4 and they will continue to fire every time step 5, 6, 7, 8 . . . because the elements Y1, Y2, Y3, Z0, Z1 and Z2 continue to fire at time steps 3, 4, 5, 6, 7, 8, . . . .

As a result of P12 firing at time 5, C33 fires at time 6, so at time 7, only P23 fires. As a result, the long term behavior (after time step 7) of P03 does not fire. Thus, E3 does not fire after time step 7, which indicates that e3=0.
Similar to that of element E3, in the long term element E4 does not fire, which indicates that e4=0. Similarly, in the long term element E5 fires, which indicates that e5=1. Similarly, in the long term element E6 fires, which indicates that e6=1. Similarly, in the long term element E7 does not fire, which indicates that e7=0.
As a consequence, multiplication of 1110*0111 equals 1100010 in binary, which represents that 14*7=98 in base 10. This active element program can execute any multiplication of two four bit binary numbers. Similar to the multiplication just described, tables 39, 40 and 41 show the multiplication steps for 11*9=99; 15*14=210; and 15*15=225.
AEM Firing Patterns Execute a Digital Computer Program
In some embodiments, an AEM using randomness deterministically executes a universal Turing machine or a von Neumann machine (digital computer program). In some embodiments, the randomness is generated using quantum phenomena. In some embodiments, the randomness is generated from a physical process. In some embodiments, the firing patterns of the active elements computing the execution of these machines are Turing incomputable. In some embodiments, the AEM accomplishes this by executing a universal Turing machine or von Neumann machine instructions with random firing interpretations. In some embodiments, if the state and tape contents of the universal Turing machine—represented by the AEM elements and connections—and the random bits generated from the random—in some embodiments, quantum—source are kept perfectly secret and no information is leaked about the dynamic connections in the AEM, then it is Turing incomputable to construct a translator Turing machine that maps the random firing interpretations back to the sequence of instructions executed by the universal Turing machine or von Neumann machine. As a consequence, in some embodiments, the AEM can deterministically execute any Turing machine (digital computer program) with active element firing patterns that are Turing incomputable. Since Turing incomputable AEM firing behavior can deterministically execute a universal Turing machine or digital computer with a finite active element machine using quantum randomness, this creates a novel computational procedure ([6], [32]). In [20], Lewis and Papadimitriou discuss the prior art notion of a digital computer's computational procedure:
Because the Turing machines can carry out any computation that can be carried out by any similar type of automata, and because these automata seem to capture the essential features of real computing machines, we take the Turing machine to be a precise formal equivalent of the intuitive notion of algorithm: nothing will be considered as an algorithm if it cannot be rendered as a Turing machine.
The principle that Turing machines are formal versions of algorithms and that no computational procedure will be considered as an algorithm unless it can be presented as a Turing machine is known as Church's thesis or the Church-Turing Thesis. It is a thesis, not a theorem, because it is not a mathematical result: It simply asserts that a certain informal concept corresponds to a certain mathematical object. It is theoretically possible, however, that Church's thesis could be overthrown at some future date, if someone were to propose an alternative model of computation that was publicly acceptable as fulfilling the requirement of finite labor at each step and yet was provably capable of carrying out computations that cannot be carried out by any Turing machine. No one considers this likely.
In a cryptographic system, Shannon [28] defines the notion of perfect secrecy.
Perfect Secrecy is defined by requiring of a system that after a cryptogram is intercepted by the enemy the a posteriori probabilities of this cryptogram representing various messages be identically the same as the a priori probabilities of the same messages before the interception.
In this context, perfect secrecy means that no information is ever released or leaked about the state and the contents of the universal Turing machine tape, the random bits generated from a quantum source and the dynamic connections of the active element machine.
In [19], Kocher et al. present differential power analysis. Differential power analysis obtains information about cryptographic computations executed by register machine hardware, by statistically analyzing the electromagnetic radiation leaked by the hardware during its computation. In some embodiments, when a quantum active element computing system is built so that its internal components remain perfectly secret or close to perfectly secret, then it may be extremely challenging for an adversary to carry out types of attacks such as differential power analysis.
Active Element Machine Interpretations of Boolean Functions
In this section, the same boolean function is computed by two or more distinct active element firing patterns, which can be executed at distinct times or by different circuits (two or more different parts) in the active element machine. These methods provide useful embodiments in a number of ways. They show how digital computer program computations can be computed differently at distinct instances. In some embodiments, distinct instances are two or more different times. In some embodiments, distinct instances use different elements and connections of the active element machine to differently compute the same Boolean function. The methods shown here demonstrate the use of level sets so that multiple active element machine firing patterns may compute the same boolean function or computer program instruction. Third, these methods demonstrate the utility of using multiple, dynamic firing interpretations to perform the same task—for example, execute a computer program—or represent the same knowledge.
The embodiments shown here enable one or more digital computer program instructions to be computed differently at different instances. In some embodiments, these different instances are different times. In some embodiments, these different instances of computing the program instruction are executed by different collections of active elements and connections in the active element machine. In some embodiments, the computer program may be an active element machine program.
The following procedure uses a random physical process to either fire input element I or not fire I at time t=n where n is a natural number {0, 1, 2, 3, . . . }. This random sequence of 0 and 1's can be generated by quantum optics, or quantum effects in a semiconductor material or other physical phenomena. The procedure is used to help execute the same computation with multiple interpretations. In some embodiments, this same computation is a program instruction executed at two different instances.
Procedure 1.
Randomness generates an AEM, representing a real number in [0, 1]. Using a random process to fire or not fire one input element I at each unit of time, a finite active element program can represent a randomly generated real number in the unit interval [0, 1]. In some embodiments, the random process is physically contained in the active element machine. In other embodiments, the random process is outside of the active element machine.
The Meta command and a random sequence of bits creates active elements 0, 1, 2, . . . that store the binary representation b0 b1 b2 . . . of real number xε[0, 1]. If input element I fires at time t=n, then bn=1; thus, create active element n so that after t=n, element n fires every unit of time indefinitely. If input element I doesn't fire at time t=n, then bn=0 and active element n is created so that it never fires. The following finite active element machine program exhibits this behavior.












(Program C (Args t)


(Connection (Time t) (From I) (To t) (Amp 2) (Width 1) (Delay 1))


(Connection (Time t+1+dT) (From I) (To t) (Amp 0))


(Connection (Time t) (From t) (To t) (Amp 2) (Width 1) (Delay 1)) )


(Element (Time clock) (Name clock)


(Threshold 1) (Refractory 1) (Last −1))


(Meta (Name I) (C (Args clock)))









Suppose a sequence of random bits—obtained from the environment or from a physical process inside the active element machine—begins with 1, 0, 1, . . . . Thus, input element I fires at times 0, 2, . . . . At time 0, the following commands are executed.












(Element (Time 0) (Name 0) (Threshold 1) (Refractory 1) (Last −1))


(C (Args 0))









The execution of (C (Args 0)) causes three connection commands to execute.












(Connection (Time 0) (From I) (To 0) (Amp 2) (Width 1) (Delay 1))


(Connection (Time 1+dT) (From I) (To 0) (Amp 0))


(Connection (Time 0) (From 0) (To 0) (Amp 2) (Width 1) (Delay 1))









Because of the first connection command
(Connection (Time 0) (From I) (To 0) (Amp 2) (Width 1) (Delay 1))
the firing of input element I at time 0 sends a pulse with amplitude 2 to element 0. Thus, element 0 fires at time 1. Then at time 1+dT, a moment after time 1, the connection from input element I to element 0 is removed. At time 0, a connection from element 0 to itself with amplitude 2 is created. As a result, element 0 continues to fire indefinitely, representing that b0=1.

At time 1, command

(Element (Time 1) (Name 1) (Threshold 1) (Refractory 1) (Last −1)) is created. Since element 1 has no connections into it and threshold 1, element 1 never fires. Thus b1=0. At time 2, input element I fires, so the following commands are executed.













(Element (Time 2) (Name 2) (Threshold 1) (Refractory 1) (Last −1))


(C (Args 2))









The execution of (C (Args 2)) causes the three connection commands to execute.












(Connection (Time 2) (From I) (To 2) (Amp 2) (Width 1) (Delay 1))


(Connection (Time 3+dT) (From I) (To 2) (Amp 0))


(Connection (Time 2) (From 2) (To 2) (Amp 2) (Width 1) (Delay 1))









Because of the first connection command
(Connection (Time 2) (From I) (To 2) (Amp 2) (Width 1) (Delay 1))
the firing of input element I at time 2 sends a pulse with amplitude 2 to element 2. Thus, element 2 fires at time 3. Then at time 3+dT, a moment after time 3, the connection from input element I to element 2 is removed. At time 2, a connection from element 2 to itself with amplitude 2 is created. As a result, element 2 continues to fire indefinitely, representing that b2=1.
Active Element Machine Firing Patterns
During a window of time, firing patterns can be put in 1-to-1 correspondence with the boolean functions ƒ:{0, 1}n→{0, 1}. In the next section, the firing pattern methods explained here are combined with procedure 1 so that a randomly chosen firing pattern can compute the functions used to execute a universal Turing machine. Consider four active elements X0, X1, X2 and X3 during window of time W=[a, b]. The refractory periods of X0, X1, X2 and X3 are chosen so that each Xk either fires or doesn't fire during window W. Thus, there are sixteen distinct firing patterns. Five of these firing patterns are shown in FIGS. 1, 2, 3, 4, and 5.
A one-to-one correspondence is constructed with the sixteen boolean functions of the form ƒ: {0, 1}×{0, 1}→{0, 1}. These boolean functions comprise the binary operators: and , or v, nand , equal , and so on. One of these firing patterns is distinguished from the other fifteen by building the appropriate connections to element P, which in the general case represents the output of a boolean function ƒ: {0, 1}n→{0, 1}. A key notion is that element P fires within the window of time W if and only if P receives a unique firing pattern from elements X0, X1, X2 and X3. (This is analogous to the notion of the grandmother nerve cell that only fires if you just saw your grandmother.) The following definition covers the Boolean interpretation explained here and also handles more complex types of interpretations.
Definition 2.1. Number of Firings During a Window
Let X denote the set of active elements {X0, X1, . . . , Xn−1} that determine the firing pattern during the window of time W. Then |(Xk, W)|=the number of times that element Xk fired during window of time W. Thus, define the number of firings during window W as




  
    
    
      (
      
        X
        ,
        W
      
      )
    
    
  
  =
  
    
      ∑
      
        k
        =
        0
      
      
        n
        -
        1
      
    
    ⁢
    
      
    
    ⁢
    
      
        
        
          (
          
            
              X
              k
            
            ,
            W
          
          )
        
        
      
      .
    
  




Observe that |(X, W)|=0 for firing pattern 0000 shown in FIG. 1 and |(X, W)|=2 for firing pattern 0011. To isolate a firing pattern so that element P only fires if this unique firing pattern occurs, set the threshold of element P=2|(X, W)|−1.
The element command for P is:
(Element (Time a−dT) (Name P) (Threshold 2|(X, W)|−1) (Refractory b−a) (Last 2a−b))
Further, if element Xk doesn't fire during window of time W, then set the amplitude of the connection from Xk to P to −2. If element Xk does fire during window of time W, then set the amplitude of the connection from Xk to P equal to 2. For each element Xk, the pulse width is set to |W|=b−a. Each connection from Xk to P is based on whether Xk is supposed to fire or is not supposed to fire during W. If Xk is supposed to fire during W, then the following connection is established. (Connection (Time a−dT) (From X_k) (To P) (Amp 2) (Width b−a) (Delay 1)) If Xk is not supposed to fire during W, then the following connection is established.
(Connection (Time a−dT) (From X_k) (To P) (Amp −2) (Width b−a) (Delay 1))
The firing pattern is already known because it is determined based on a random source of bits received by input elements, as discussed in procedure 1. Consequently, −2|(X, W)| is already known. How an active element circuit is designed to create a firing pattern that computes the appropriate boolean function is discussed in the following example.
EXAMPLE
Computing ⊕ with Firing Pattern 0010
Consider firing pattern 0010. In other words, X2 fires but the other elements do not fire. The AEM is supposed to compute the boolean function exclusive-or A⊕B=(AB)(AB). The goal here is to design an AEM circuit such that A⊕B=1 if and only if the firing pattern for X0, X1, X2, X3 is 0010. Following definition 2.1, as a result of the distinct firing pattern during W, if A⊕B=1 then P fires. If A⊕B=0 then P doesn't fire. Below are the commands that connect elements A and B to elements X0, X1, X2, X3.












(Connection (Time a−2) (From A) (To X_0) (Amp 2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_0) (Amp 2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_0) (Threshold 3) (Refractory b−a) (Last


2a−b))


(Connection (Time a−2) (From A) (To X_1) (Amp −2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_1) (Amp −2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_1) (Threshold −1) (Refractory b−a) (Last


2a−b))


(Connection (Time a−2) (From A) (To X_2) (Amp 2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_2) (Amp 2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_2) (Threshold 1) (Refractory b−a) (Last


2a−b))


(Connection (Time a−2) (From A) (To X_3) (Amp 2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_3) (Amp 2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_3) (Threshold 3) (Refractory b−a) (Last


2a−b))









There are four cases for A⊕B: 1⊕0, 0⊕1, 1⊕1 and 0⊕0. In regard to this, choose the refractory periods so that A and B either fire or don't fire at t=0. Recall that W=[a, b]. In this example, assume a=2 and b=3. Thus, all refractory periods of X0, X1, X2, X3 are 1 and all last time fireds are 1. All pulse widths are the length of the window W+1 which equals 2.
Case 1. Element A fires at time t=0 and element B doesn't fire at t=0.
Element X0 receives a pulse from A with amplitude 2 at time t=2. Element X0 doesn't fire because its threshold=3. Element X1 receives a pulse from A with amplitude −2 at time t=2. Element X1 doesn't fire during W because X1 has threshold=−1. Element X2 receives a pulse from A with amplitude 2. Element X2 fires at time t=2 because its threshold is 1. Element X3 receives a pulse from A with amplitude 2 but doesn't fire during window W because X3 has threshold=3.
Case 2. Element X0 receives a pulse from B with amplitude 2 at time t=2.
Element X0 doesn't fire because its threshold=3. Element X1 receives a pulse from B with amplitude −2 at time t=2. Element X1 doesn't fire during W because X1 has threshold=−1. Element X2 receives a pulse from B with amplitude 2. Element X2 fires at time t=2 because its threshold is 1. Element X3 receives a pulse from B with amplitude 2, but doesn't fire during window W because X3 has threshold=3.
Case 3. Element A fires at time t=0 and element B fires at t=0.
Element X0 receives two pulses from A and B each with amplitude 2 at time t=2. Element X0 fires because its threshold=3. Element X1 receives two pulses from A and B each with amplitude −2 at time t=2. Element X1 doesn't fire during W because X1 has threshold=−1. Element X2 receives two pulses from A and B each with amplitude 2. Element X2 fires at time t=2 because its threshold is 1. Element X3 receives two pulses from A and B each with amplitude 2. Element X3 fires at time t=2 because X3 has threshold=3.
Case 4. Element A doesn't fire at time t=0 and element B doesn't fire at t=0. Thus, elements X0, X2 and X3 do not fire because they have positive thresholds. Element X1 fires at t=2 because it has threshold=−1.
For the desired firing pattern 0010, the threshold of P=2|(X, W)|−1=1. Below is the element command for P.
(Element (Time 2−dT) (Name P) (Threshold 1) (Refractory 1) (Last 1)).
Below are the connection commands for making P fire if and only if firing pattern 0010 occurs during W.












(Connection (Time 2−dT) (From X_0) (To P) (Amp −2) (Width 1)


(Delay 1))


(Connection (Time 2−dT) (From X_1) (To P) (Amp −2) (Width 1)


(Delay 1))


(Connection (Time 2−dT) (From X_2) (To P) (Amp 2) (Width 1) (Delay


1))


(Connection (Time 2−dT) (From X_3) (To P) (Amp −2) (Width 1)


(Delay 1))









For cases 1 and 2 (i.e., 1⊕0 and 0⊕1) only X2 fires. A moment before X2 fires at t=2 (i.e., −dT), the amplitude from X2 to P is set to 2. At time t=2, a pulse with amplitude 2 is sent from X2 to P, so P fires at time t=3 since its threshold=1. In other words, 1⊕0=1 or 0⊕1=1 has been computed. For case 3, (1⊕1), X0, X2 and X3 fire. Thus, two pulses each with amplitude=−2 are sent from X0 and X3 to P. And one pulse with amplitude 2 is sent from X2 to P. Thus, P doesn't fire. In other words, 1⊕1=0 has been computed. For case 4, (0⊕0), X1 fires. One pulse with amplitude=−2 is sent to X2. Thus, P doesn't fire. In other words, 0⊕0=0 has been computed.
Level Set Separation Rules
This section describes how any of the sixteen boolean functions are uniquely mapped to one of the sixteen firing patterns by an appropriate active element machine program. The domain {0, 1}×{0, 1} of the sixteen boolean functions has four members {(0, 0), (1, 0), (0, 1), (1, 1)}. Furthermore, for each active element Xk, separate these members based on the (amplitude from A to Xk, amplitude from B to Xk, threshold of Xk, element Xk) quadruplet. For example, the quadruplet (0, 2, 1, X1) separates {(1, 1), (0, 1)} from {(1, 0), (0, 0)} with respect to X1. Recall that A=1 means A fires and B=1 means B fires. Then X1 will fire with inputs {(1, 1), (0, 1)} and X1 will not fire with inputs {(1, 0), (0, 0)}. The separation rule is expressed as




  
    (
    
      0
      ,
      2
      ,
      1
      ,
      
        X
        1
      
    
    )
  
  ↔
  
    
      
        {
        
          
            (
            
              1
              ,
              1
            
            )
          
          ,
          
            (
            
              0
              ,
              1
            
            )
          
        
        }
      
      
        {
        
          
            (
            
              1
              ,
              0
            
            )
          
          ,
          
            (
            
              0
              ,
              0
            
            )
          
        
        }
      
    
    .
  




Similarly,





  
    (
    
      0
      ,
      
        -
        2
      
      ,
      
        -
        1
      
      ,
      
        X
        2
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
    
      {
      
        
          (
          
            1
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
      
      }
    
  




indicates that X2 has threshold −1 and amplitudes 0 and −2 from A and B respectively. Further, X2 will fire with inputs {(1, 0), (0, 0)} and will not fire with inputs {(1, 1), (0, 1)}.

Table 1 shows how to compute all sixteen boolean functions ƒk: {0, 1}×{0, 1}→{0, 1}. For each X, use one of 14 separation rules to map the level set ƒk−1{1} or alternatively map the level set ƒk−1{0} to one of the sixteen firing patterns represented by X0, X1, X2 and X3. The level set method works as follows.
Suppose the nand boolean function ƒ13=(AB) is to be computed with the firing pattern 0101. Observe that ƒ13−1{1}={(1, 0), (0, 1), (0, 0)}. Thus, the separation rules




  
    (
    
      2
      ,
      2
      ,
      3
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        (
        
          1
          ,
          1
        
        )
      
      }
    
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
  




for k in {0, 2} work because X0 and X2 fire if and only if A fires and B fires. Similarly,





  
    (
    
      
        -
        2
      
      ,
      
        -
        2
      
      ,
      
        -
        3
      
      ,
      
        X
        j
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
    
      {
      
        (
        
          1
          ,
          1
        
        )
      
      }
    
  




for j in {1, 3} work because X1 and X3 don't fire if and only if A fires and B fires. These rules generate the commands.













(Connection (Time a−2) (From A) (To X_0) (Amp 2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_0) (Amp 2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_0) (Threshold 3) (Refractory b−a) (Last


2a−b))


(Connection (Time a−2) (From A) (To X_1) (Amp −2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_1) (Amp −2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_1) (Threshold −3) (Refractory b−a)


(Last 2a−b))


(Connection (Time a−2) (From A) (To X_2) (Amp 2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_2) (Amp 2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_2) (Threshold 3) (Refractory b−a) (Last


2a−b))


(Connection (Time a−2) (From A) (To X_3) (Amp −2) (Width b−a+1)


(Delay 2))


(Connection (Time a−2) (From B) (To X_3) (Amp −2) (Width b−a+1)


(Delay 2))


(Element (Time a−2) (Name X_3) (Threshold −3) (Refractory b−a)


(Last 2a−b))









The five commands make element P fire if and only if firing pattern 0101 occurs.












(Element (Time 2−dT) (Name P) (Threshold 3) (Refractory 1) (Last 1))


(Connection (Time 2−dT) (From X_0) (To P) (Amp −2) (Width 1)


(Delay 1))


(Connection (Time 2−dT) (From X_1) (To P) (Amp 2) (Width 1) (Delay


1))


(Connection (Time 2−dT) (From X_2) (To P) (Amp −2) (Width 1)


(Delay 1))


(Connection (Time 2−dT) (From X_3) (To P) (Amp 2) (Width 1) (Delay


1))









Case 1: (00). A doesn't fire and B doesn't fire. Thus, no pulses reach X1 and X3, who each have threshold −3. Thus, X1 and X3 fire. Similarly, no pulses reach X0 and X2, who each have threshold 3. Thus, the firing pattern 0101 shown in table 10 causes P to fire because element X1 and X3 each send a pulse with amplitude 2 to P which has threshold 3. Therefore, (00)=1 is computed.
Case 2: (10). A fires and B doesn't fire. Thus, one pulse from A with amplitude 2 reaches X0 and X2, who each have threshold 3. Thus, X0 and X2 don't fire. Similarly, one pulse from A with amplitude −2 reaches X1 and X3, who each have threshold −3. Thus, the firing pattern 0101 shown in table 11 causes P to fire because element X1 and X3 each send a pulse with amplitude 2 to P which has threshold 3. Therefore, (10)=1 is computed.
Case 3: (01). A doesn't fire and B fires. Thus, one pulse from B with amplitude 2 reaches X0 and X2, who each have threshold 3. Thus, X0 and X2 don't fire. Similarly, one pulse from B with amplitude −2 reaches X1 and X3, who each have threshold −3. Thus, the firing pattern 0101 shown in table 12 causes P to fire because element X1 and X3 each send a pulse with amplitude 2 to P which has threshold 3. Therefore, (01)=1 is computed.
Case 4: (11). A fires and B fires. Thus, two pulses each with amplitude 2 reach X0 and X2, who each have threshold 3. Thus, X0 and X2 fire. Similarly, two pulses each with amplitude −2 reach X1 and X3, who each have threshold −3. As a result, X1 and X3 don't fire. Thus, the firing pattern 1010 shown in table 13 prevents P from firing because X0 and X2 each send a pulse with amplitude −2 to P which has threshold 3. Therefore, (11)=0 is computed.
Overall, any one of the sixteen boolean functions in table 1 are uniquely mapped to one of the sixteen firing patterns by an appropriate AEM program. These mappings can be chosen arbitrarily: as a consequence, each register machine instruction can be executed at different times using distinct AEM firing representations.
Executing a Digital Computer with Random Firing Interpretations
A universal Turing Machine (UTM) is a Turing machine that can execute the computation of any Turing Machine by reading the other Turing Machine's description and input from the UTM's tape. Table 2 shows Minsky's universal Turing machine described in [24]. This means that this universal Turing machine can execute any program that a digital computer or a distruted system computers or a vonNeumann machine can execute.
The elements of {0, 1}2 are denoted as {00, 01, 10, 11}. Create a one-to-one correspondence between the tape symbols in the alphabet  and the elements in {0, 1}2 as follows: 000, 101, y10 and A11. Furthermore, consider the following correspondence of the states with the elements of {0, 1}3: q1001, q2010, q3011, q4100, q5101, q6110, q7111 and the halting state h000. Further consider L0 and R1 in {0, 1}. An active element machine is designed to compute the universal Turing Machine program η shown in table 3. Following the methods in the previous section, multiple AEM firing interpretations are created that compute η. When the universal Turing machine halts, η(011, 00)=(000, 00, h), this special case is handled with a halting firing pattern  that the active element machine enters. Concatenate the three boolean variables U, W, X to represent the current state of the UTM. The two boolean variables Y, Z represent the current tape symbol. From table 3, observe that η=(η0 η1 η2, η3 η4, η5). For each k such that 0≦k≦5, the level sets of the function ηk: {0, 1}3×{0, 1}2→{0, 1} are shown below.
η0−1(UWX, YZ){1}={(111, 10), (111, 01), (111, 00), (110, 11), (110, 10), (110, 01), (101, 11), (101, 10), (101, 01), (100, 11), (100, 10), (100, 01), (100, 00), (011, 11) (010, 11)}
η0−1(UWX, YZ){0}={(111, 11), (110, 00), (101, 00), (011, 10), (011, 01), (011, 00), (010, 10), (010, 01), (010, 00), (001, 11), (001, 10), (001, 01), (001, 00), (000, 11), (000, 10), (000, 01), (000, 00)}
η1−1(UWX, YZ){1}={(111, 11), (111, 10), (111, 01), (111, 00), (110, 11), (110, 10), (110, 01), (110, 00), (101, 00), (100, 01), (011, 10), (011, 01), (010, 11), (010, 01), (010, 00), (001, 01)}
η1−1(UWX, YZ){0}={(101, 11), (101, 10), (101, 01), (100, 11), (100, 10), (100, 00), (011, 11), (011, 00), (010, 10), (001, 11), (001, 10), (001, 00), (000, 11), (000, 10), (000, 01), (000, 00)}
η2−1(UWX, YZ){1}={011, 10), (111, 01), (110, 00), (101, 11), (101, 10), (101, 01), (101, 00), (100, 01), (100, 00), (011, 10), (011, 01), (010, 10), (001, 11), (001, 10), (001, 00)}
η2−1(UWX, YZ){0}={(111, 11), (111, 00), (110, 11), (110, 10), (110, 01), (100, 11), (100, 10), (011, 11), (011, 00), (010, 11), (010, 01), (010, 00), (001, 01), (000, 11), (000, 10), (000, 01), (000, 00)}
η3−1(UWX, YZ){1}={(111, 00), (110, 00), (110, 01), (110, 10), (101, 00), (101, 01), (101, 10), (100, 00), (100, 10), (011, 01), (011, 10), (010, 11), (010, 01), (010, 00)}
η4−1(UWX, YZ){0}={(111, 01), (111, 10), (111, 11), (110, 11), (101, 11), (100, 01), (100, 11), (011, 00), (011, 11), (010, 10), (001, 00), (001, 01), (001, 10), (001, 11), (000, 01), (000, 10), (000, 11), (000, 00)}
η4−1(UWX, YZ){1}={(111, 01), (110, 11), (110, 01), (110, 00), (101, 11), (101, 01), (100, 11), (100, 01), (011, 11), (011, 01), (010, 01), (001, 11), (001, 01)}
η4−1(UWX, YZ){0}={(111, 11), (111, 10), (111, 00), (110, 10), (101, 10), (101, 00), (100, 10), (100, 00), (011, 10), (011, 00), (010, 11), (010, 10), (010, 00), (001, 10), (001, 00), (000, 11), (000, 10), (000, 01), (000, 00)}
η5−1(UWX, YZ){1}=(111, 11), (111, 10), (111, 01), (111, 00), (110, 11), (110, 10), (110, 01), (101, 11), (101, 10), (101, 01), (100, 00), (010, 11), (010, 01), (010, 00)
η5−1(UWX, YZ){0}={(110, 00), (101, 00), (100, 11), (100, 10), (100, 01), (011, 11), (011, 10), (011, 01), (010, 10), (001, 11), (001, 10), (001, 01), (001, 00), (000, 11), (000, 10)}(000, 01), (000, 00)
The level set η5−1(UWX, YZ){h}={(011, 00)} is the special case when the universal Turing machine halts. At this time, the active element machine reaches a halting firing pattern H. The next example copies one element's firing state to another element's firing state, which helps assign the value of a random bit to an active element and perform other functions in the UTM.
Copy Program.
This active element program copies active element a's firing state to element b.












(Program copy (Args s t b a)









(Element (Time s−1) (Name b) (Threshold 1) (Refractory 1) (Last



s−1))



(Connection (Time s−1)(From a) (To b)(Amp 0) (Width 0) (Delay 1))



(Connection (Time s) (From a) (To b) (Amp 2) (Width 1) (Delay 1))



(Connection (Time s) (From b) (To b) (Amp 2) (Width 1) (Delay 1))



(Connection (Time t) (From a) (To b) (Amp 0) (Width 0) (Delay 1))







)









When the copy program is called, active element b fires if a fired during the window of time [s, t). Further, a connection is set up from b to b so that b will keep firing indefinitely. This enables b to store active element a's firing state. The following procedure describes the computation of the Turing program with random firing interpretations.
Procedure 2. Computing Turing Program with Random Firing Patterns Consider function η3: {0, 1}5→{0, 1} as previously defined. The following scheme for mapping boolean values 1 and 0 to the firing of an active element is used. If active element U fires during window W, then this corresponds to input U=1 in η3; if active element U doesn't fire during window W, then this corresponds to input U=0 in η3. When U fires, W doesn't fire, X fires, Y doesn't fire and Z doesn't fire, this corresponds to computing η3 (101, 00). The value 1=η3(101, 00) is the underlined bit in (011, 10, 0), which is located in row 101, column 00 of table 3. Procedure 1 and the separation rules in table 4 are synthesized so that is computed using random active element firing patterns. In other words, the boolean function r73 can be computed using an active element machine's dynamic interpretation. The dynamic part of the interpretation is determined by the random bits received from a quantum source. The firing activity of active element P3 represents the value of η3 (UWX, YZ). Fourteen random bits are read from a quantum random generator—for example, see [5]. These random bits are used to create a corresponding random firing pattern of active elements R0, R1, . . . R13. Meta commands dynamically build active elements and connections based on the separation rules in table 4 and the firing activity of elements R0, R1, . . . R13. These dynamically created active elements and connections determine the firing activity of active element P3 based on the firing activity of active elements U, W, X, Y and Z. The details of this procedure are described below.
Read fourteen random bits a0, a1, . . . and a13 from a quantum source. The values of these random bits are stored in active elements R0, R1, . . . R13. If random bit ak=1, then Rk fires; if random bit ak=0, then Rk doesn't fire.
Set up dynamical connections from active elements U, X, W, Y, Z to elements D0, D1, . . . D13. These connections are based on Meta commands that use the firing pattern from elements R0, R1, . . . R13.












(Program set_dynamic_C (Args s t f xk a w tau rk)


 (Connection (Time s−dT) (From f) (To xk) (Amp −a) (Width w) (Delay


 tau))


 (Meta (Name rk) (Window s t)









(Connection (Time t) (From f) (To xk) (Amp a) (Width w) (Delay



tau)))







)


(Program set_dynamic_E (Args s t xk theta r L rk)


 (Element (Time s−2dT) (Name xk) (Threshold −theta) (Refractory r)


 (Last L))


 (Meta (Name rk) (Window s t)









(Element (Time t) (Name xk) (Threshold theta) (Refractory r) (Last



L)))







)









For D0, follow the first row of separation table 4, reading the amplitudes from U, W, X, Y, Z to D0 and the threshold for D0. Observe that at time s-dT program set_dynamic_C initializes the amplitudes of the connections to AU,D0=−2, AW,D0=−2, AX,D0=−2, AY,D0=2, AZ,D0=2 as if R0 doesn't fire. If R0 does fire, then the Meta command in set_dynamic_C dynamically flips the sign of each of these amplitudes: at time t, the amplitudes are flipped to AU,D0=2, AW,D0=2, AX,D0=2, AY,D0=−2, AZ,D0=−2.
Similarly, the meta command in set_dynamic_E initializes the threshold of D0 to θD0=−5 as if R0 doesn't not fire. If R0 does fire the meta command flips the sign of the threshold of D0; for the D0 case, the meta command sets θD0=5.














(set_dynamic_E s t D0 5 1 s−2 R0)



(set_dynamic_C s t U D0 2 1 1 R0)



(set_dynamic_C s t W D0 2 1 1 R0)



(set_dynamic_C s t X D0 2 1 1 R0)



(set_dynamic_C s t Y D0 −2 1 1 R0)



(set_dynamic_C s t Z D0 −2 1 1 R0)









Similarly, for elements D1, . . . , D13, the commands set_dynamic_E and set_dynamic_C dynamically set the element parameters and the connections from U, X, W, Y, Z to D1, . . . D13 based on the rest of the quantum random firing pattern R1, . . . , R13.














(set_dynamic_E s t D1 3 1 s−2 R1)



(set_dynamic_C s t U D1 2 1 1 R1)



(set_dynamic_C s t W D1 2 1 1 R1)



(set_dynamic_C s t X D1 −2 1 1 R1)



(set_dynamic_C s t Y D1 −2 1 1 R1)



(set_dynamic_C s t Z D1 −2 1 1 R1)



(set_dynamic_E s t D2 5 1 s−2 R2)



(set_dynamic_C s t U D2 2 1 1 R2)



(set_dynamic_C s t W D2 2 1 1 R2)



(set_dynamic_C s t X D2 −2 1 1 R2)



(set_dynamic_C s t Y D2 −2 1 1 R2)



(set_dynamic_C s t Z D2 2 1 1 R2)



(set_dynamic_E s t D3 5 1 s−2 R3)



(set_dynamic_C s t U D3 2 1 1 R3)



(set_dynamic_C s t W D3 2 1 1 R3)



(set_dynamic_C s t X D3 −2 1 1 R3)



(set_dynamic_C s t Y D3 2 1 1 R3)



(set_dynamic_C s t Z D3 −2 1 1 R3)



(set_dynamic_E s t D4 3 1 s−2 R4)



(set_dynamic_C s t U D4 2 1 1 R4)



(set_dynamic_C s t W D4 −2 1 1 R4)



(set_dynamic_C s t X D4 2 1 1 R4)



(set_dynamic_C s t Y D4 −2 1 1 R4)



(set_dynamic_C s t Z D4 −2 1 1 R4)



(set_dynamic_E s t D5 5 1 s−2 R5)



(set_dynamic_C s t U D5 2 1 1 R5)



(set_dynamic_C s t W D5 −2 1 1 R5)



(set_dynamic_C s t X D5 2 1 1 R5)



(set_dynamic_C s t Y D5 −2 1 1 R5)



(set_dynamic_C s t Z D5 2 1 1 R5)



(set_dynamic_E s t D6 5 1 s−2 R6)



(set_dynamic_C s t U D6 2 1 1 R6)



(set_dynamic_C s t W D6 −2 1 1 R6)



(set_dynamic_C s t X D6 2 1 1 R6)



(set_dynamic_C s t Y D6 2 1 1 R6)



(set_dynamic_C s t Z D6 −2 1 1 R6)



(set_dynamic_E s t D7 1 1 s−2 R7)



(set_dynamic_C s t U D7 2 1 1 R7)



(set_dynamic_C s t W D7 −2 1 1 R7)



(set_dynamic_C s t X D7 −2 1 1 R7)



(set_dynamic_C s t Y D7 −2 1 1 R7)



(set_dynamic_C s t Z D7 −2 1 1 R7)



(set_dynamic_E s t D8 3 1 s−2 R8)



(set_dynamic_C s t U D8 2 1 1 R8)



(set_dynamic_C s t W D8 −2 1 1 R8)



(set_dynamic_C s t X D8 −2 1 1 R8)



(set_dynamic_C s t Y D8 2 1 1 R8)



(set_dynamic_C s t Z D8 −2 1 1 R8)



(set_dynamic_E s t D9 5 1 s−2 R9)



(set_dynamic_C s t U D9 −2 1 1 R9)



(set_dynamic_C s t W D9 2 1 1 R9)



(set_dynamic_C s t X D9 2 1 1 R9)



(set_dynamic_C s t Y D9 −2 1 1 R9)



(set_dynamic_C s t Z D9 2 1 1 R9)



(set_dynamic_E s t D10 5 1 s−2 R10)



(set_dynamic_C s t U D10 −2 1 1 R10)



(set_dynamic_C s t W D10 2 1 1 R10)



(set_dynamic_C s t X D10 2 1 1 R10)



(set_dynamic_C s t Y D10 2 1 1 R10)



(set_dynamic_C s t Z D10 −2 1 1 R10)



(set_dynamic_E s t D11 1 1 s−2 R11)



(set_dynamic_C s t U D11 −2 1 1 R11)



(set_dynamic_C s t W D11 2 1 1 R11)



(set_dynamic_C s t X D11 −2 1 1 R11)



(set_dynamic_C s t Y D11 −2 1 1 R11)



(set_dynamic_C s t Z D11 −2 1 1 R11)



(set_dynamic_E s t D12 3 1 s−2 R12)



(set_dynamic_C s t U D12 −2 1 1 R12)



(set_dynamic_C s t W D12 2 1 1 R12)



(set_dynamic_C s t X D12 −2 1 1 R12)



(set_dynamic_C s t Y D12 −2 1 1 R12)



(set_dynamic_C s t Z D12 2 1 1 R12)



(set_dynamic_E s t D13 5 1 s−2 R13)



(set_dynamic_C s t U D13 −2 1 1 R13)



(set_dynamic_C s t W D13 2 1 1 R13)



(set_dynamic_C s t X D13 −2 1 1 R13)



(set_dynamic_C s t Y D13 2 1 1 R13)



(set_dynamic_C s t Z D13 2 1 1 R13)









Set up connections to active elements G0, G1, G2, . . . G14 which represent the number of elements in {R0, R1, R2, . . . R13} that are firing. If 0 are firing, then only G0 is firing. Otherwise, if k>0 elements in {R0, R1, R2, . . . R13} are firing, then only G1, G2, . . . Gk are firing.












(Program firing_count (Args G a b theta)









(Element (Time a−2dT) (Name G) (Threshold theta) (Refractory b−a)



(Last 2a−b))



(Connection (Time a−dT) (From R0) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R1) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R2) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R3) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R4) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R5) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R6) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R7) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R8) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R9) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R10) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R11) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R12) (To G) (Amp 2) (Width b−a)



(Delay 1))



(Connection (Time a−dT) (From R13) (To G) (Amp 2) (Width b−a)



(Delay 1))







)


(firing_count G0 a b −1)


(firing_count G1 a b 1)


(firing_count G2 a b 3)


(firing_count G3 a b 5)


(firing_count G4 a b 7)


(firing_count G5 a b 9)


(firing_count G6 a b 11)


(firing_count G7 a b 13)


(firing_count G8 a b 15)


(firing_count G9 a b 17)


(firing_count G10 a b 19)


(firing_count G11 a b 21)


(firing_count G12 a b 23)


(firing_count G13 a b 25)


(firing_count G14 a b 27)









P3 is the output of η3. Initialize element P3's threshold based on meta commands that use the information from elements G0, G1, . . . G13. Observe that t+dT <t+2dT < . . . <t+15dT so the infinitesimal dT enables us to set the appropriate threshold for P3 to −2(14−k)+1 based on k denoting the number of firings. For example, if nine of the randomly chosen bits are high, then G9 will fire, so the threshold of P3 is set to −9. If five of the random bits are high, then the threshold of P3 is set to −17. Each element of the level set creates a firing pattern of D0, D1, . . . D13 equal to the complement of the random firing pattern R0, R1, . . . R13 (i.e., Dk fires if and only if Rk does not fire).












(Program set_P_threshold (Args G P s t a b theta kdT)


 (Meta (Name G) (Window s t)









(Element (Time t+kdT) (Name P) (Threshold theta) (Refractory b−a)



(Last t−b+a))







)


(set_P_threshold G0 P3 s t a b −27 dT)


(set_P_threshold G1 P3 s t a b −25 2dT)


(set_P_threshold G2 P3 s t a b −23 3dT)


(set_P_threshold G3 P3 s t a b −21 4dT)


(set_P_threshold G4 P3 s t a b −19 5dT)


(set_P_threshold G5 P3 s t a b −17 6dT)


(set_P_threshold G6 P3 s t a b −15 7dT)


(set_P_threshold G7 P3 s t a b −13 8dT)


(set_P_threshold G8 P3 s t a b −11 9dT)


(set_P_threshold G9 P3 s t a b −9 10dT)


(set_P_threshold G10 P3 s t a b −7 11dT)


(set_P_threshold G11 P3 s t a b −5 12dT)


(set_P_threshold G12 P3 s t a b −3 13dT)


(set_P_threshold G13 P3 s t a b −1 14dT)


(set_P_threshold G14 P3 s t a b 1 15dT)









Set up dynamical connections from D0, D1, . . . D13 to P3 based on the random bits stored by R0, R1, . . . R13. These connections are based on meta commands that use the firing pattern from elements R0, R1, . . . R13.












(Program set_from_Xk_to_Pj (Args s t Xk Pj amp w tau Rk)









(Connection (Time s−dT) (From Xk) (To Pj) (Amp −amp) (Width w)



(Delay tau))



(Meta (Name Rk) (Window s t)









(Connection (Time t) (From Xk) (To Pj) (Amp amp) (Width w)



(Delay tau))







)


(set_from_Xk_to_Pj s t D0 P3 2 b−a 1 R0)


(set_from_Xk_to_Pj s t D1 P3 2 b−a 1 R1)


(set_from_Xk_to_Pj s t D2 P3 2 b−a 1 R2)


(set_from_Xk_to_Pj s t D3 P3 2 b−a 1 R3)


(set_from_Xk_to_Pj s t D4 P3 2 b−a 1 R4)


(set_from_Xk_to_Pj s t D5 P3 2 b−a 1 R5)


(set_from_Xk_to_Pj s t D6 P3 2 b−a 1 R6)


(set_from_Xk_to_Pj s t D7 P3 2 b−a 1 R7)


(set_from_Xk_to_Pj s t D8 P3 2 b−a 1 R8)


(set_from_Xk_to_Pj s t D9 P3 2 b−a 1 R9)


(set_from_Xk_to_Pj s t D10 P3 2 b−a 1 R10)


(set_from_Xk_to_Pj s t D11 P3 2 b−a 1 R11)


(set_from_Xk_to_Pj s t D12 P3 2 b−a 1 R12)


(set_from_Xk_to_Pj s t D13 P3 2 b−a 1 R13)









Similar procedures use random firing patterns on active elements {A0, A1, . . . A14}, {B0, B1, . . . B15}, {C0, C1, . . . C14}, {E0, E1, . . . E12}, and {F0, F1, . . . F13} to compute η0, η1, η2, η4 and η5, respectively. The outputs of η0, ƒ1, η2, η4 and η5 are represented by active elements P0, P1, P2, P4 and P5, respectively. The level set rules for η0, η1, η2, η4 and η5 are shown, respectively in tables 5, 6, 7, 8 and 9.
Since the firing activity of element Pk represents a single bit that helps determine the next state or next tape symbol during a UTM computational step, its firing activity and parameters can be assumed to remain perfectly secret. Alternatively, if an eavesdropper is able to listen to the firing activity of P0, P1, P2, P3, P4 and P5, which collectively represent the computation of η(UXW, YZ), then this leaking of information could be used to reconstruct some or all of the UTM tape contents.
This weakness can be rectified as follows. For each UTM computational step, the active element machine uses six additional quantum random bits b0, b1, b2, b3, b4 and b5. For element P3, if random bit b3=1, then the dynamical connections from D0, D1, . . . D13 to P3 are chosen as described above. However, if random bit b3=0, then the amplitudes of the connections from D0, D1, . . . D13 to P3 and the threshold of P3 are multiplied by −1. This causes P3 to fire when η(UXW, YZ)=0 and P3 doesn't fire when η(UXW, YZ)=1.
This cloaking of P3's firing activity can be coordinated with a meta command based on the value of b3 so that P3's firing can be appropriately interpreted to dynamically change the active elements and connections that update the tape contents and state after each UTM computational step. This cloaking procedure can also be used for element P0 and random bit b0, P1 and random bit b1, P2 and random bit b2, P4 and random bit b4, and P5 and random bit b5.
Besides representing and computing the program η with quantum random firing patterns, there are other important functions computed by active elements executing the UTM. Assume that these connections and the active element firing activity are kept perfectly secret as they represent the state and the tape contents of the UTM tape contents. These functions are described below.
Three active elements (q 0), (q 1) and (q 2) store the current state of the UTM.
There are a collection of elements to represent the tape head location k where k is an integer.
A marker active element  locates the leftmost tape square and a separate marker active element  locates the rightmost tape square. Any tape symbols outside these markers are assumed to be blank i.e. 0. If the tape head moves beyond the leftmost tape square, then 's connection is removed and updated one tape square to the left and the machine is reading a 0. If the tape head moves beyond the rightmost tape square, then 's connection is removed and updated one tape square to the right and the machine is reading a 0.
There are a collection of elements that represent the tape contents of the UTM. For each tape square k inside the marker elements, there are two elements named (S k) and (T k) whose firing pattern determines the alphabet symbol at tape square k. For example, if elements (S 5) and (T 5) are not firing, then tape square 5 contains alphabet symbol 0. If element (S −7) is firing and element (T −7) is not firing, then tape square −7 contains alphabet symbol 1. If element (S 13) is firing and element (T 13) is firing, then tape square 13 contains alphabet symbol A.
Representing alphabet symbol 0 with two active elements that are not firing is convenient because if the tape head moves beyond the initial tape contents of the UTM, then the Meta command can add two elements that are not firing to represent the contents of the new square.
The copy program can be used to construct important functionality in the UTM. The following program enables a new alphabet symbol to be copied to the tape.














(Program copy_symbol (Args s t b0 a0 b1 a1)









(copy s t b0 a0)



(copy s t b1 a1)









)









The following program enables a new state to be copied.















(Program copy_state (Args s t b0 a0 b1 a1 b2 a2)









(copy s t b0 a0)



(copy s t b1 a1)



(copy s t b2 a2)









)









The sequence of steps by which the UTM is executed with an AEM are described.
1. Tape contents are initialized and the marker elements L and R are initialized.
2. The tape head is initialized to tape square k=0 and the current machine state is initialized to q2. In other words, (q 0) is not firing (q 1) is firing and (q 2) is not firing.
3. (S k) and (T k) are copied to au, and the current state (q 0), (q 1), (q 2) is copied to qin.
4. η(q1n, ain)=(qout, aout, m) is computed where qout represents the new state, aout represents the new tape symbol and m represents the tape head move.
5. If qout=h, then the UTM halts. The AEM reaches a static firing pattern that stores the current tape contents indefinitely and keeps the tape head fixed at tape square k where the UTM halted.
6. Otherwise, the firing pattern of the three elements representing qout are copied to (q 0), (q 1), (q 2). aout is copied to the current tape square represented by (S k), (T k).
7. If m=L, then first determine if the tape head has moved to the left of the tape square marked by . If so, then have  remove its current marker and mark tape square k−1. In either case, go back to step 3 where (S k−1) and (T k−1) are copied to ain.
8. If m=R, then first determine if the tape head has moved to the right of the tape square marked by . If so, then have  remove its current marker and mark tape square k+1. In either case, go back to step 3 where (S k+1) and (T k+1) are copied to ain.
Calude and Svozil showed that quantum randomness is Turing incomputable. Since the firing pattern of the active elements {A0, A1, . . . A14} computing η0; the firing pattern of elements {B0, B1, . . . B15} computing η1; the firing pattern of elements {C0, C1, . . . C14} computing η2; the firing pattern of elements {D0, D1, . . . D13} computing η3; the firing pattern of elements {E0, E1, . . . E12} computing η4; and the firing pattern of elements {F0, F1, . . . F13} computing are all generated from quantum randomness, these firing patterns are Turing incomputable. As a consequence, there does not exist a Turing machine that can map these firing patterns back to the sequence of instructions executed by the universal Turing machine. In summary, these methods demonstrate a new class of computing machines where the purpose of the program's execution is incomprehensible (Turing incomputable) to malware.

Affine Fixed Points

Remark 1.1 Linear Maps as Matrices
The linear maps L and M are represented with matrices in the standard basis.




  
    L
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              a
            
            
              b
            
          
          
            
              c
            
            
              d
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
      ⁢
      
        
      
      ⁢
      
        M
        ⁡
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
    
    =
    
      
        (
        
          
            
              h
            
            
              i
            
          
          
            
              j
            
            
              k
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
  




Each affine transformation is of the form




  
    f
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      L
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




where L or





   
  
    (
    
      
        
          a
        
        
          b
        
      
      
        
          c
        
        
          d
        
      
    
    )
  




is called the linear part and





   
  
    (
    
      
        
          m
        
      
      
        
          n
        
      
    
    )
  




is called the translational part. The unit square with lower left corner at coordinate (j, k) is denoted as U(j, k)={(x,y):j≦x≦j+1 & k≦y≦k+1} or it is sometimes represented with the corners of the square [(j, k), (j+1, k), (j+1, k+1), (j, k+1)].

Remark 1.3 Computation of the Composition of the Affine Maps




  
    g
    ∘
    
      f
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
  
  =
  
    
      
        (
        
          
            
              
                ah
                +
                ci
              
            
            
              
                bh
                +
                di
              
            
          
          
            
              
                aj
                +
                ck
              
            
            
              
                bj
                +
                dk
              
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            
              mh
              +
              ni
              +
              p
            
          
        
        
          
            
              mj
              +
              nk
              +
              q
            
          
        
      
      )
    
  




Definition 1.4 Rectangular Area Preserving Affine Maps
An affine transformation r is called an rectangular area preserving affine transformation if it is of the form




  
    
      r
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    =
    
      
        
          (
          
            
              
                
                  1
                  A
                
              
              
                0
              
            
            
              
                0
              
              
                A
              
            
          
          )
        
        ⁢
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
      ⁢
      
        
      
      +
      
        (
        
          
            
              m
            
          
          
            
              n
            
          
        
        )
      
    
  
  ⁢
  
    
  




for some A>0. In the next section, A is a number of the form Bk, where k is an integer and B is an integer greater than 1, and m, n are rational numbers.

Remark 1.5 Rectangular Area Preserving Affine Maps are Closed.
Rectangular area preserving affine maps are closed under function composition. Consider



  
    
      
        r
        1
      
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    =
    
      
        
          (
          
            
              
                
                  1
                  A
                
              
              
                0
              
            
            
              
                0
              
              
                A
              
            
          
          )
        
        ⁢
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
      ⁢
      
        
      
      +
      
        
          (
          
            
              
                m
              
            
            
              
                n
              
            
          
          )
        
        ⁢
        
          
        
        ⁢
        and
      
    
  




  
    
      
        r
        2
      
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    =
    
      
        
          (
          
            
              
                
                  1
                  B
                
              
              
                0
              
            
            
              
                0
              
              
                B
              
            
          
          )
        
        ⁢
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
      ⁢
      
        
      
      +
      
        
          (
          
            
              
                p
              
            
            
              
                q
              
            
          
          )
        
        ⁢
        
          
        
        .
        
          

        
        ⁢
        
          
            
              
                
                  
                    Then
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        r
                        1
                      
                      ∘
                      
                        
                          r
                          2
                        
                        ⁡
                        
                          (
                          
                            
                              
                                x
                              
                            
                            
                              
                                y
                              
                            
                          
                          )
                        
                      
                    
                  
                  =
                  
                  ⁢
                  
                    
                      
                        (
                        
                          
                            
                              
                                1
                                AB
                              
                            
                            
                              0
                            
                          
                          
                            
                              0
                            
                            
                              AB
                            
                          
                        
                        )
                      
                      ⁢
                      
                        (
                        
                          
                            
                              x
                            
                          
                          
                            
                              y
                            
                          
                        
                        )
                      
                    
                    ⁢
                    
                      
                    
                    +
                    
                      (
                      
                        
                          
                            
                              
                                m
                                B
                              
                              +
                              p
                            
                          
                        
                        
                          
                            
                              nB
                              +
                              q
                            
                          
                        
                      
                      )
                    
                  
                
                ⁢
                
                  
                
              
            
          
          
            
              
                =
                
                ⁢
                
                  
                    
                      (
                      
                        
                          
                            
                              1
                              AB
                            
                          
                          
                            0
                          
                        
                        
                          
                            0
                          
                          
                            AB
                          
                        
                      
                      )
                    
                    ⁢
                    
                      (
                      
                        
                          
                            x
                          
                        
                        
                          
                            y
                          
                        
                      
                      )
                    
                  
                  ⁢
                  
                    
                  
                  +
                  
                    (
                    
                      
                        
                          
                            
                              p
                              A
                            
                            +
                            m
                          
                        
                      
                      
                        
                          
                            qA
                            +
                            n
                          
                        
                      
                    
                    )
                  
                
              
            
          
        
      
    
  



Remark 1.6
If bc+(1−a)(d−1)≠0 then




  
    f
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              a
            
            
              b
            
          
          
            
              c
            
            
              d
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




has a fixed point at





  
    (
    
      
        
          
            
              (
              
                d
                -
                1
              
              )
            
            ⁢
            m
          
          -
          bn
        
        
          bc
          +
          
            
              (
              
                1
                -
                a
              
              )
            
            ⁢
            
              (
              
                d
                -
                1
              
              )
            
          
        
      
      ,
      
        
          
            
              (
              
                a
                -
                1
              
              )
            
            ⁢
            n
          
          -
          cm
        
        
          bc
          +
          
            
              (
              
                1
                -
                a
              
              )
            
            ⁢
            
              (
              
                d
                -
                1
              
              )
            
          
        
      
    
    )
  
  .




Remark 1.7
When b=c=0 and (1−a)(d−1)≠0, then




  
    f
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              a
            
            
              0
            
          
          
            
              0
            
            
              d
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




has a fixed point at





  
    (
    
      
        m
        
          1
          -
          a
        
      
      ,
      
        n
        
          1
          -
          d
        
      
    
    )
  
  .




Definition 1.8 Vertical Covers
Consider the rectangular area preserving affine map




  
    
      r
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    =
    
      
        
          (
          
            
              
                
                  1
                  A
                
              
              
                0
              
            
            
              
                0
              
              
                A
              
            
          
          )
        
        ⁢
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
      ⁢
      
        
      
      +
      
        (
        
          
            
              m
            
          
          
            
              n
            
          
        
        )
      
    
  
  ⁢
  
    
  




where A>1 and with square domain W=[(u, v), (u+s, v), (u+s, v+s), (u, v+s)] with sides of length s. r (W) vertically covers W if and only if all four conditions A, B, C and D hold.

1.) The y-coordinate of r(u, v)<v.
2.) The y-coordinate of r(u+s, v+s)≧v+s.
C. The x-coordinate of r(u, v)≧u.
D. The x-coordinate of r(u+s, v+s)≦u+s.
See FIG. 14.
Remark 1.9 Vertical Cover Fixed Point
When a=1/A and d=A such that A>1, then




  
    
      r
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    =
    
      
        
          (
          
            
              
                
                  1
                  A
                
              
              
                0
              
            
            
              
                0
              
              
                A
              
            
          
          )
        
        ⁢
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
      ⁢
      
        
      
      +
      
        (
        
          
            
              m
            
          
          
            
              n
            
          
        
        )
      
    
  
  ⁢
  
    
  




has a fixed point at





  
    (
    
      
        
          m
          ⁢
          
            
          
          ⁢
          A
        
        
          A
          -
          1
        
      
      ,
      
        n
        
          1
          -
          A
        
      
    
    )
  
  .




On square W=[(0,0), (s,0), (s,s), (0,s)], the image of affine map r on W is





  
    r
    ⁡
    
      (
      W
      )
    
  
  =
  
    [
    
      
        (
        
          m
          ,
          n
        
        )
      
      ,
      
        (
        
          
            m
            +
            
              s
              A
            
          
          ,
          n
        
        )
      
      ,
      
        (
        
          
            m
            +
            
              s
              A
            
          
          ,
          
            n
            +
            sA
          
        
        )
      
      ,
      
        (
        
          m
          ,
          
            n
            +
            sA
          
        
        )
      
    
    ]
  




which is a rectangle with width





  s
  A




and height sA.

Definition 1.10 Horizontal Covers
Consider the rectangular area preserving affine map




  
    r
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              A
            
            
              0
            
          
          
            
              0
            
            
              
                1
                A
              
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




where A>1 and with square domain W=[(u, v), (u+s, v), (u+s, v+s), (u, v+s)] with sides of length s. r(W) horizontally covers W if and only if all four conditions hold:

1.) The x-coordinate of r(u, v)≦u.
2.) The x-coordinate of r(u+s, v+s)≧u+s.
C. The y-coordinate of r(u, v)≧v.
D. The y-coordinate of r(u+s, v+s)≦v+s.
See FIG. 15.
Remark 1.11 Horizontal Cover Fixed Point
When a=A and




  d
  =
  
    1
    A
  




such that A>1, then





  
    r
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              A
            
            
              0
            
          
          
            
              0
            
            
              
                1
                A
              
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




has a fixed point





  
    (
    
      
        m
        
          1
          -
          A
        
      
      ,
      
        nA
        
          A
          -
          1
        
      
    
    )
  
  .




On square W=[(0, 0), (s, 0), (s, s), (0, s)]





  
    r
    ⁡
    
      (
      W
      )
    
  
  =
  
    [
    
      
        
          (
          
            m
            ,
            n
          
          )
        
        ⁢
        
          (
          
            
              m
              +
              sA
            
            ,
            n
          
          )
        
      
      ,
      
        (
        
          
            m
            +
            sA
          
          ,
          
            n
            +
            
              s
              A
            
          
        
        )
      
      ,
      
        (
        
          m
          ,
          
            n
            +
            
              s
              A
            
          
        
        )
      
    
    ]
  




is a rectangle with width sA and height





  
    s
    A
  
  .




Example 1.12




  
    r
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              
                1
                /
                2
              
            
            
              0
            
          
          
            
              0
            
            
              2
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            
              4
              10
            
          
        
        
          
            
              1
              10
            
          
        
      
      )
    
  




with standard unit square U(0, 0). The fixed point





  (
  
    
      8
      10
    
    ,
    
      
        -
        1
      
      10
    
  
  )




is not in U(0,0). The geometry is shown in FIG. 16.

Theorem 1.13 Vertical Covering Fixed Point Theorem
Consider the rectangular, area-preserving affine map




  
    r
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              
                1
                A
              
            
            
              0
            
          
          
            
              0
            
            
              A
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




for some A>1 and square W=[(u, v), (u+s, v), (u+s, v+s) (u, v+s)]. Then r(W) vertically covers W if and only if fixed point





  (
  
    
      mA
      
        A
        -
        1
      
    
    ,
    
      n
      
        1
        -
        A
      
    
  
  )




lies in W.

PROOF. Define




  
    
      r
      ′
    
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      r
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    -
    
      (
      
        
          
            u
          
        
        
          
            v
          
        
      
      )
    
  




to translate W so that W is a square of sides with length s with lower left corner at the origin. Thus, WLOG it can be assumed that the square domain W=[(0, 0), (s, 0), (s, s), (0, s)]. Observe that r(0, 0)=(m, n) and





  
    r
    ⁡
    
      (
      
        s
        ,
        s
      
      )
    
  
  =
  
    
      (
      
        
          m
          +
          
            s
            A
          
        
        ,
        
          n
          +
          sA
        
      
      )
    
    .
  




See FIG. 17. Hence,

1.) The y-coordinate of r(0, 0)=n

2.) The y-coordinate of r(s, s)=n+sA

3.) The x-coordinate of r(0, 0)=m

4.) The x-coordinate of





  
    r
    ⁡
    
      (
      
        s
        ,
        s
      
      )
    
  
  =
  
    m
    +
    
      
        s
        A
      
      ⁢
      
        (
        ⇔
        )
      
      ⁢
      
        (
        
          
            mA
            
              A
              -
              1
            
          
          ,
          
            n
            
              1
              -
              A
            
          
        
        )
      
    
  




lies in W if and only if





  0
  ≤
  
    n
    
      1
      -
      A
    
  
  ≤
  
    s
    ⁢
    
      
    
    ⁢
    AND
    ⁢
    
      
    
    ⁢
    0
  
  ≤
  
    mA
    
      A
      -
      1
    
  
  ≤
  s




if and only if [n≦0 AND n≧(1−A)s] AND [0≦mA≦(A−1)s]

if and only if





  
    [
    
      n
      ≤
      
        
          0
          ⁢
          
            
          
          ⁢
          AND
          ⁢
          
            
          
          ⁢
          n
        
        +
        sA
      
      ≥
      s
    
    ]
  
  ⁢
  
    
  
  ⁢
  
    AND
    ⁢
    
      
    
    [
    
      0
      ≤
      
        
          m
          ⁢
          
            
          
          ⁢
          AND
          ⁢
          
            
          
          ⁢
          m
        
        +
        
          s
          A
        
      
      ≤
      s
    
    ]
  




if and only if [The y-coordinate of r(0, 0)≦0] AND [the y-coordinate of r(s, s)≦s] AND [the x-coordinate of r(0, 0)≧0] AND [the x-coordinate of r(s, s)≦s]

Theorem 1.14 Horizontal Covering Fixed Point Theorem
Consider the rectangular, area-preserving affine map




  
    r
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              A
            
            
              0
            
          
          
            
              0
            
            
              
                1
                A
              
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




for some A>1 and square W=[(u, v), (u+s, v), (u+s, v+s) (u, v+s)].

Then r(W) horizontally covers W if and only if fixed point




  (
  
    
      m
      
        1
        -
        A
      
    
    ,
    
      nA
      
        A
        -
        1
      
    
  
  )




lies in W.

PROOF. Define




  
    
      r
      ′
    
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      r
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    -
    
      (
      
        
          
            u
          
        
        
          
            v
          
        
      
      )
    
  




to translate W so that W is the square with lower left corner at the origin. Thus, WLOG it can be assumed that W=[(0, 0), (s, 0), (s, s), (0, s)].

Observe r(0, 0)=(m, n) and





  
    r
    ⁡
    
      (
      
        s
        ,
        s
      
      )
    
  
  =
  
    
      (
      
        
          m
          +
          sA
        
        ,
        
          n
          +
          
            s
            A
          
        
      
      )
    
    .
  




See FIG. 18.

Hence,

1.) The x-coordinate of r(0, 0)=m
2.) The x-coordinate of r(s, s)=m+sA
3.) The y-coordinate of r(0, 0)=n
4.) The y-coordinate of




  
    r
    ⁡
    
      (
      
        s
        ,
        s
      
      )
    
  
  =
  
    n
    +
    
      
        s
        A
      
      ⁢
      
        (
        ⇔
        )
      
      ⁢
      
        (
        
          
            m
            
              1
              -
              A
            
          
          ,
          
            nA
            
              A
              -
              1
            
          
        
        )
      
    
  




lies in W if and only if





  0
  ≤
  
    m
    
      1
      -
      A
    
  
  ≤
  
    s
    ⁢
    
      
    
    ⁢
    and
    ⁢
    
      
    
    ⁢
    0
  
  ≤
  
    nA
    
      A
      -
      1
    
  
  ≤
  s




if and only if [m≦0 AND m≧A)s] and [0≦nA≦(A−1)s]

if and only if





  
    [
    
      m
      ≤
      
        
          0
          ⁢
          
            
          
          ⁢
          AND
          ⁢
          
            
          
          ⁢
          m
        
        +
        sA
      
      ≥
      s
    
    ]
  
  ⁢
  
    
  
  ⁢
  
    and
    ⁢
    
      
    
    [
    
      0
      ≤
      
        
          n
          ⁢
          
            
          
          ⁢
          AND
          ⁢
          
            
          
          ⁢
          n
        
        +
        
          s
          A
        
      
      ≤
      s
    
    ]
  




if and only if [The x-coordinate of r(0, 0)≦0] AND [the x-coordinate of r(s, s)≧s]

AND [the y-coordinate of r(0, 0)≧0] AND [the y-coordinate of r(s, s)≦s].
Turing Machine and Affine Map Correspondence
Definition 2.1 Turing Machine
A Turing machine is a triple (Q, A, η) where

    
    
        There is a unique state h, called the halt state.
        Q is a finite set of states that does not contain the halt state h. The states are represented as Q={q1, q2, . . . qK} or as the natural numbers Q={2, . . . , K} and the halt state as 1. Before machine execution begins, there is a starting state s and s is an element of Q.
        L and R are special symbols that instruct the machine to advance to the left square or to the right square on the tape T.
        A is a finite set of alphabet symbols that are read from and written to the tape. The alphabet symbols are denoted as A={a1, a2, . . . , aJ} or as the natural numbers A={1, 2, . . . , J}. A does not contain the symbols L, R.
        η is a function where η: Q×A→(Q∪{h})×A×{L, R}.
    
    


The η function acts as the program for the Turing machine in the following manner. For each q in Q and a in A, the expression η(q, a)=(r, β, x) describes how machine (Q, A, η) executes one computational step. When in state q and scanning alphabet symbol a on the tape:

    
    
        1.) Machine (Q, A, η) changes to state r.
        2.) Machine (Q, A, η) rewrites alphabet symbol a as symbol β on the tape.
        3.) If x=L, then machine (Q, A, η) moves its tape head one square to the left on the tape and is subsequently scanning the symbol in this square.
        4.) If x=R, then machine (Q, A, η) moves its tape head one square to the right on the tape and is subsequently scanning the symbol in this square.
    
    


5.) If r=h, machine (Q, A, η) enters the halting state h, and the machine stops (halts).
Definition 2.2 Turing Machine Tape
The Turing machine tape T is represented as a function T: Z→A where Z denotes the integers. The tape T is M-bounded if there exists a bound M>0 such that for T(k)=T(j) whenever |j|, |k|>M. (In some cases, the blank symbol # is used and T(k)=# when |k|>M) The symbol on the kth square of the tape is denoted as Tk. Here we do not assume the tape is M-bounded unless it is explicitly stated for particular cases.
Definition 2.3 Turing Machine Configuration with Tape Head Location
Let (Q, A, η) be a Turing machine with tape T. A configuration is an element of the set =(Q∪{h})×Z×{T: T is tape with range A}. The standard definition of a Turing machine assumes the initial tape is M-bounded and the tape contains only blank symbols, denoted as #, outside the bound.
If (q, k, T) is a configuration in , then k is called the tape head location. The tape head location is M-bounded if there exists a natural number M>0 such that the tape head location k satisfies |k|≦M. A configuration whose first coordinate equals h is called a halted configuration. The set of non-halting configurations is ={(q, k, T)ε: q≠h}
The purpose of the definition of a configuration is that the first coordinate stores the current state of the Turing machine, the third coordinate stores the contents of the tape, and the second coordinate stores the location of the tape head on the tape. Before presenting some examples of configurations, it is noted that there are different methods to describe the tape contents. One method is




  
    T
    ⁡
    
      (
      k
      )
    
  
  =
  
    
      {
      
        
          
            
              α
              k
            
          
          
            
              
                if
                ⁢
                
                  
                
                ⁢
                l
              
              ≤
              k
              ≤
              n
            
          
        
        
          
            #
          
          
            otherwise
          
        
      
      }
    
    .
  




This is a max{|l|, |n|}-bounded tape. Another convenient representation is to list the tape contents and underline the symbol to indicate the location of the tape head. ( . . . ##αβ## . . . ).

A diagram can also represent the tape, tape head location, and the configuration (q, k, T). See FIG. 19.
Example 2.4
Turing Machine Configuration
Consider configuration (p, 2, . . . ##αβ## . . . ). The first coordinate indicates that the Turing machine is in state p. The second coordinate indicates that its tape head is currently scanning tape square 2, denoted as T2 or T(2). The third coordinate indicates that tape square 1 contains symbol α, tape square 2 contains symbol β, and all other tape squares contain the # symbol.
Example 2.5
Halt Configuration Represented as Natural Numbers
A second example of a configuration is (1, 6, . . . 1111233111 . . . ). This configuration is a halted configuration. The first coordinate indicates that the machine is in halt state 1. The second coordinate indicates that the tape head is scanning tape square 6. The underlined 2 in the third coordinate indicates that the tape head is currently scanning a 2. In other words, T(6)=2, T(7)=3, T(8)=3, and T(k)=1 when k<6 OR k>8.
Definition 2.6 Turing Machine Computational Step
Consider machine (Q, A, η) with configuration (q, k, T) such that T(k)=α. After the execution of one computational step, the new configuration is one of the three cases such that for all three cases S(k)=β and S(j)=T(j) whenever j≠k:
Case I. (r, k−1, 5) if η(q, α)=(r,β, L).
Case II. (r, k+1, S) if η(q, α)=(r, β, R).
Case III. (h, k, 7). In this case, the machine execution stops (halts).
If the machine is currently in configuration (q0, k0, T0) and over the next n steps the sequence of machine configurations (points) is (q0, k0, T0), (qn, kn, Tn), . . . , (qn, kn, Tn) then this execution sequence is sometimes called the next n+1 computational steps.
If Turing machine (Q, A, η) with initial configuration (s, k, T) reaches the halt state h after a finite number of execution steps, then the machine execution halts. Otherwise, it is said that the machine execution is immortal on initial configuration (s, k, T).
The program symbol η induces a map η: → where η(q, k, T)=(r, k−1, S) when η(q, α)=(r, β, L) and η(q, k, T)=(r, k+1, S) when η(q, α)=(r, β, R).
Definition 2.7 Turing Program Length
The program length is the number of elements in the domain of η. The program length is denoted as |η|. Observe that |η|=|Q×A|=|Q∥A|. Note that in [7] and [32], they omit quintuples (q, a, r, b, x) when r is the halting state. In our representation, η(q, a)=(1, b, x) or η(q, a)=(h, b, x).
Definition 2.8 Tape Head glb , lub , Window of Execution [, ]
Suppose a Turing machine begins or continues its execution with tape head at tape square k. During the next N computational steps, the greatest lower bound  of the tape head is the left most (smallest integer) tape square that the tape head visits during these N computational steps; and the least upper bound  of the tape head is the right most (largest integer) tape square that the tape head visits during these N computational steps. The window of execution denoted as [, ] or [, +1, . . . , −1, ] is the sequence of integers representing the tape squares that the tape head visited during these N computational steps. The length of the window of execution is −+1 which is also the number of distinct tape squares visited by the tape head during these N steps. To express the window of execution for the next n computational steps, the lower and upper bounds are expressed as a function of n: [(n), (n)].
Example 2.9
Q={q, r, s, t, u, v, w, x}. A={1, 2}. Halting State=h















η(q, 1) = (r, 1, R).
η(q, 2) = (h, 2, R).
η(r, 1) = (h, 1, R).
η(r, 2) = (s, 2, R).


η(s, 1) = (t, 1, R).
η(s, 2) = (h, 2, R).
η(t, 1) = (h, 1, R).
η(t, 2) = (u, 2, R).


η(u, 1) = (h, 1, R).
η(u, 2) = (v, 1, R).
η(v, 1) = (h, 1, R).
η(v, 2) = (w, 2, R).


η(w, 1) = (h, 1, R).
η(w, 2) = (x, 1, L).
η(x, 1) = (h, 1, R).
η(x, 2) = (q, 2, R).









Left pattern = 12.
Spanning Middle Pattern = 121 2212.
Right pattern = 212.









The machine execution steps are shown in FIG. 20 with tape head initially at square 1. The tape head location is underlined. The tape head moves are {R6LR}n. The point p=[q, 121 212222] is an immortal periodic point with period 8 and hyperbolic degree 6.
Remark 2.10 If j≦k, then [(j), (j)]⊂[(k), (k)]
This follows immediately from the definition of the window of execution.
Since the tape squares may be renumbered without changing the results of the machine execution, for convenience it is often assumed that the machine starts execution at tape square 0. In example 2.9, during the next 8 computational steps—one cycle of the immortal periodic point—the window of execution is [0, 6]. The length of the window of execution is 7: Observe that if the tape squares are renumbered and the goal is to refer to two different windows of execution, for example [(j), (j)] and [(k), (k)], then both windows are renumbered with the same relative offset so that the two windows can be compared.
Definition 2.11 Value Function and Base
Suppose the alphabet A={a1, a2, . . . , aJ} and the states are Q={q1, q2, . . . qK}. Define the symbol value function v: A∪Q∪{h}→N where N denotes the natural numbers. v(h)=0. v(ak)=k. v(qk)=k+|A|. v(qK)=|Q|+|A|. Choose the number base B=|Q|+|A|+1. Observe that 0≦v(x)<B and that each symbol chosen from A∪Q∪{h} has a unique value in base B.
Definition 2.12 Turing Machine Program Isomorphism
Two Turing machines M1(Q1, A1, η1) and M2(Q2, A2, η2) have a program isomorphism denoted as Ψ: M1→M2 if

    
    
        A. There is a function φ: Q1→Q2 that is a bijection.
        B. There is a function γ: A1→A2 that is a bijection.
        C. There is a function Ψ: M1→M2 such that for each pair (q, a) in Q1×A1 Ψ(η1(q, a))=η2(φ(q), γ(a))
    
    


Remark 2.13 If alphabet A={a}, then the halting behavior of the Turing machine is completely determined in ≦|Q|+1 execution steps.
PROOF. Suppose Q={q1, q2, . . . qK}. Observe that the program length is |η|=|Q|. Also, after an execution step every tape symbol on the tape must be a. Consider the possible execution steps: η(qS(1), a)→η(qS(2), a)→η(qS(3), a) . . . →η(qS(K+1), a). If the program execution does not halt in these |Q|+1 steps, then S(i)=S(j) for some i≠j; and the tape contents are still all a's. Thus, the program will exhibit periodic behavior whereby it will execute η(qS(i), a)→ . . . →η(qS(j), a) indefinitely. If the program does not halt in |Q|+1 execution steps, then the program will never halt.
As a result of Remark 2.13, from now on, it is assumed that |A|≧2. Further, since at least one state is needed, then from here on, it is assumed that the base B≧3.
Definition 2.14 Turing Machine Configuration to x-y plane P correspondence. See FIG. 19. For a fixed machine (Q, A, η), each configuration (q, k, T) represents a unique point (x, y) in P. The coordinate functions x: →P and y: →P, where  is the set of configurations, are x(q, k, T)=Tk Tk+1. Tk+2 Tk+3 Tk+4 . . . where this decimal sequence in base B represents the real number




  
    
      Bv
      ⁡
      
        (
        
          T
          k
        
        )
      
    
    +
    
      v
      ⁡
      
        (
        
          T
          
            k
            +
            1
          
        
        )
      
    
    +
    
      
        ∑
        
          j
          =
          1
        
        x
      
      ⁢
      
        
          v
          ⁡
          
            (
            
              T
              
                k
                +
                j
                +
                1
              
            
            )
          
        
        ⁢
        
          B
          
            -
            j
          
        
        ⁢
        
          y
          ⁡
          
            (
            
              q
              ,
              k
              ,
              T
            
            )
          
        
      
    
  
  =
  
    
      
        qT
        
          k
          -
          1
        
      
      ·
      
        T
        
          k
          -
          2
        
      
    
    ⁢
    
      T
      
        k
        -
        3
      
    
    ⁢
    
      T
      
        k
        -
        4
      
    
    ⁢
    
      
    
    ⁢
    ...
  




where this decimal sequence in base B represents a real number as





  
    Bv
    ⁡
    
      (
      q
      )
    
  
  +
  
    v
    ⁡
    
      (
      
        T
        
          k
          -
          1
        
      
      )
    
  
  +
  
    
      ∑
      
        j
        =
        1
      
      ∝
    
    ⁢
    
      
        v
        ⁡
        
          (
          
            T
            
              k
              -
              j
              -
              1
            
          
          )
        
      
      ⁢
      
        B
        
          -
          j
        
      
    
  




Define function φ: →P as φ(q, k, T) (x(q, k, T), y(q, k, T)). φ is the function that maps machine configurations into points into the plane P.

Definition 2.15 Equivalent Configurations
With respect to Turing machine (Q, A, η), the two configurations (q, k, T) and (q, j, V) are equivalent [i.e. (q, k, T) ̃(q, j, V)] if T(m)=V(m+j−k) for every integer m. Observe that  ̃ is an equivalence relation on . Let ′ denote the set of equivalence classes [(q, k, T)] on  Also observe that φ maps every configuration in equivalence class [(q, k, T)] to the same ordered pair of real numbers in P. Recall that (D, X) is a metric space if the following three conditions hold.
1. D(a, b)≧0 for all a, b in X where equality holds if and only if a=b.
2. D(a, b)=D(b, a) for all a, b. (Symmetric)
3. D(a, b)=D(a, c)+D(c, b) for all a, b, c in X. (Triangle inequality.)
(ρ, ′) is a metric space where ρ is induced via φ by the Euclidean metric in P. Consider points p1, p2 in P with p=(x1, y1) and p2=(x2, y2) where (d, P) is a metric space with Euclidean metric d(p1, P2)=√{square root over ((x1−x2)2+(y1−y2)2)}{square root over ((x1−x2)2+(y1−y2)2)}
Let u=[(q, k, S)], w=[(r, l, T)] be elements of ′. Define ρ: ′×′→R as ρ(u, w)=d (φ(u),




  
    
      φ
      ⁡
      
        (
        w
        )
      
    
    )
  
  =
  
    
      
        
          [
          
            
              x
              ⁡
              
                (
                
                  q
                  ,
                  k
                  ,
                  S
                
                )
              
            
            -
            
              x
              ⁡
              
                (
                
                  r
                  ,
                  l
                  ,
                  T
                
                )
              
            
          
          ]
        
        2
      
      +
      
        
          [
          
            y
            ⁡
            
              (
              
                r
                ,
                l
                ,
                T
              
              )
            
          
          ]
        
        2
      
    
  




The symmetric property and the triangle inequality hold for ρ because d is a metric. In regard to property (i), ρ(u, w)≧0 because d is a metric. The additional condition that ρ(u, w)=0 if and only if u=w holds because d is a metric and because the equivalence relation—collapses non-equal equivalent configurations (i.e. two configurations in the same state but with different tape head locations and with all corresponding symbols on their respective tapes being equal) into the same point in ′.
The unit square U(└x┘, └y┘) has a lower left corner with coordinates (└x┘, └y┘) where └x┘=Bv(Tk)+v(Tk+1) and └y┘=Bv(q)+v(Tk−1). See FIG. 21.
Definition 2.16 Left Affine Function
This is for case I. where η(q, Tk)=(r, β, L). See FIG. 22.

xTk−1β·Tk+1Tk+2Tk+3 . . .

B−1x=Tk·Tk+1Tk+2Tk+3Tk+4 

Thus, m=Tk−1β−Tk where the subtraction of integers is in base B.

yrTk−2·Tk−3Tk−4Tk−5 . . .

By=qTk−1Tk−2·Tk−3Tk−4Tk−5 . . .

Thus, n=rTk−2−qTk−1Tk−2 where the subtraction of integers is in base B.
Define the left affine function F(└x┘, └y┘): U(└x┘, └y┘)→P where




  
    
      
        F
        
          (
          
            
              ⌊
              x
              ⌋
            
            ,
            
              ⌊
              y
              ⌋
            
          
          )
        
      
      ⁡
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    =
    
      
        
          (
          
            
              
                
                  1
                  B
                
              
              
                0
              
            
            
              
                0
              
              
                B
              
            
          
          )
        
        ⁢
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
      +
      
        (
        
          
            
              m
            
          
          
            
              n
            
          
        
        )
      
    
  
  ,




m=Bv(Tk−1)+v(β)−v(Tk) and n=Bv(r)−B2v(q)−Bv(Tk−1).

Lemma 2.17 Left Affine FunctionTuring Machine Computational Step
Let (q, k, T) be a Turing machine configuration. Suppose η(q, Tk)=(r, b, L) for some state r in Q∪{h} and some alphabet symbol b in A and where Tk=a. Consider the next Turing Machine computational step. The new configuration is (r, k−1, Tb) where Tb(j)=T(j) for every j≠k and Tb(k)=b. The commutative diagram φη(q, k, T)=F(└x┘, └y┘) φ(q, k, T) holds. In other words, F(└x┘, └y┘) [x(q, k, T), y(q, k, T)]=[x(r, k−1, Tb), y(r, k−1, Tb)].
PROOF. x(r, k−1, Tb)=Tk−1b·Tk+1 Tk+2 . . .
The x coordinate of



  
    
      
        
          
            
              F
              
                (
                
                  
                    ⌊
                    x
                    ⌋
                  
                  ,
                  
                    ⌊
                    y
                    ⌋
                  
                
                )
              
            
            ⁡
            
              [
              
                
                  x
                  ⁡
                  
                    (
                    
                      q
                      ,
                      k
                      ,
                      T
                    
                    )
                  
                
                ,
                
                  y
                  ⁡
                  
                    (
                    
                      q
                      ,
                      k
                      ,
                      T
                    
                    )
                  
                
              
              ]
            
          
          =
          
          ⁢
          
            
              
                B
                
                  -
                  1
                
              
              ⁢
              
                x
                ⁡
                
                  (
                  
                    q
                    ,
                    k
                    ,
                    T
                  
                  )
                
              
            
            +
            
              Bv
              ⁡
              
                (
                
                  T
                  
                    k
                    -
                    1
                  
                
                )
              
            
            +
            
              v
              ⁡
              
                (
                b
                )
              
            
            -
            
              v
              ⁡
              
                (
                a
                )
              
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              
                B
                
                  -
                  1
                
              
              (
              
                
                  
                    aT
                    
                      k
                      +
                      1
                    
                  
                  ·
                  
                    T
                    
                      k
                      +
                      2
                    
                  
                
                ⁢
                
                  T
                  
                    k
                    +
                    3
                  
                
                ⁢
                
                  
                
                ⁢
                ...
              
              ⁢
              
                
              
              )
            
            +
            
              Bv
              ⁡
              
                (
                
                  T
                  
                    k
                    -
                    1
                  
                
                )
              
            
            +
          
        
      
    
    
      
        
          
          ⁢
          
            
              v
              ⁢
              
                (
                b
                )
              
            
            -
            
              v
              ⁡
              
                (
                a
                )
              
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              
                a
                ·
                
                  T
                  
                    k
                    +
                    1
                  
                
              
              ⁢
              
                T
                
                  k
                  +
                  2
                
              
              ⁢
              
                T
                
                  k
                  +
                  3
                
              
              ⁢
              
                
              
              ⁢
              ...
            
            ⁢
            
              
            
            +
            
              Bv
              ⁡
              
                (
                
                  T
                  
                    k
                    -
                    1
                  
                
                )
              
            
            +
          
        
      
    
    
      
        
          
          ⁢
          
            
              v
              ⁢
              
                (
                b
                )
              
            
            -
            
              v
              ⁡
              
                (
                a
                )
              
            
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              T
              
                k
                -
                1
              
            
            ⁢
            
              b
              ·
              
                T
                
                  k
                  +
                  1
                
              
            
            ⁢
            
              T
              
                k
                +
                2
              
            
            ⁢
            
              T
              
                k
                +
                3
              
            
            ⁢
            
              
            
            ⁢
            ...
          
        
      
    
  




  
    
      
    
    ⁢
    
      
        y
        ⁡
        
          (
          
            r
            ,
            
              k
              -
              1
            
            ,
            
              T
              b
            
          
          )
        
      
      =
      
        
          
            rT
            
              k
              -
              2
            
          
          ·
          
            T
            
              k
              -
              3
            
          
        
        ⁢
        
          T
          
            k
            -
            4
          
        
        ⁢
        
          
        
        ⁢
        ...
      
    
  



The y coordinate of




  
    
      
        
          
            F
            
              (
              
                
                  ⌊
                  x
                  ⌋
                
                ,
                
                  ⌊
                  y
                  ⌋
                
              
              )
            
          
          ⁡
          
            [
            
              
                x
                ⁡
                
                  (
                  
                    q
                    ,
                    k
                    ,
                    T
                  
                  )
                
              
              ,
              
                y
                ⁡
                
                  (
                  
                    q
                    ,
                    k
                    ,
                    T
                  
                  )
                
              
            
            ]
          
        
        =
        
        ⁢
        
          
            By
            ⁡
            
              (
              
                q
                ,
                k
                ,
                T
              
              )
            
          
          +
          
            Bv
            ⁡
            
              (
              r
              )
            
          
          -
          
            
              B
              2
            
            ⁢
            
              v
              ⁡
              
                (
                q
                )
              
            
          
          -
          
            
              Bv
              ⁡
              
                (
                
                  T
                  
                    k
                    -
                    1
                  
                
                )
              
            
            .
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            B
            (
            
              
                
                  qT
                  
                    k
                    -
                    1
                  
                
                ·
                
                  T
                  
                    k
                    -
                    2
                  
                
              
              ⁢
              
                T
                
                  k
                  -
                  3
                
              
              ⁢
              
                
              
              ⁢
              ...
            
            ⁢
            
              
            
            )
          
          +
          
            Bv
            ⁡
            
              (
              r
              )
            
          
          -
          
            
              B
              2
            
            ⁢
            
              v
              ⁡
              
                (
                q
                )
              
            
          
          -
        
      
    
  
  
    
      
        
        ⁢
        
          
            Bv
            ⁡
            
              (
              
                T
                
                  k
                  -
                  1
                
              
              )
            
          
          .
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            
              qT
              
                k
                -
                1
              
            
            ⁢
            
              
                T
                
                  k
                  -
                  2
                
              
              ·
              
                T
                
                  k
                  -
                  3
                
              
            
            ⁢
            
              
            
            ⁢
            ...
          
          +
          
            Bv
            ⁡
            
              (
              r
              )
            
          
          -
          
            
              B
              2
            
            ⁢
            
              v
              ⁡
              
                (
                q
                )
              
            
          
          -
        
      
    
  
  
    
      
        
        ⁢
        
          
            Bv
            ⁡
            
              (
              
                T
                
                  k
                  -
                  1
                
              
              )
            
          
          .
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            
              rT
              
                k
                -
                2
              
            
            ·
            
              T
              
                k
                -
                3
              
            
          
          ⁢
          
            T
            
              k
              -
              4
            
          
          ⁢
          
            
          
          ⁢
          ...
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            y
            ⁡
            
              (
              
                r
                ,
                
                  k
                  -
                  1
                
                ,
                
                  T
                  b
                
              
              )
            
          
          .
        
      
    
  




Remark 2.18 Minimum vertical translation for left affine function As in 2.16, n is the vertical translation. |Bv(r)−Bv(Tk−1)|=B|v(r)−v(Tk−1)|≦B(B−1). Since q is a state, v(q)≧(|A|+1). This implies |−−B2v(q)|≧(|A|+1)B2 This implies that |n|≧(|A|+1)B2−B(B−1)≧|A|B2+B.
Thus, |n|≧|A|B2+B.
Definition 2.19 Right Affine Function
This is for case II. where η(q, Tk)=(r, β, R). See FIG. 23.

xTk+1Tk+2·Tk+3Tk+4 . . .

Bx=TkTk+1 Tk+2·Tk+3Tk+4 . . .

Thus, m=Tk+1Tk+2−TkTk+1Tk+2 where the subtraction of integers is in base B.

yrβ·Tk−1Tk−2Tk−3 . . .

B−1y=q·Tk−1Tk−2Tk−3 . . .

Thus, n=rβ−q where the subtraction of integers is in base B.
Define the right affine function G(└x┘, └y┘): U(└x┘, └y┘)→P such that




  
    
      g
      
        (
        
          
            ⌊
            x
            ⌋
          
          ,
          
            ⌊
            y
            ⌋
          
        
        )
      
    
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              B
            
            
              0
            
          
          
            
              0
            
            
              
                1
                B
              
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            m
          
        
        
          
            n
          
        
      
      )
    
  




where m=−B2v(Tk) and n=Bv(r)+v(β)−v(q).

Lemma 2.20 Right Affine FunctionTuring Machine Computational Step
Let (q, k, T) be a Turing machine configuration. Suppose η(q, Tk)=(r, b, R) for some state r in Q∪{h} and some alphabet symbol b in A and where Tk=a. Consider the next Turing Machine computational step. The new configuration is (r, k+1, Tb) where Tb(j)=T(j) for every j≠k and Tb(k)=b. The commutative diagram  η(q, k, T)=G(└x┘, └y┘)φ(q, k, T) holds.
In other words, G(└x┘, └y┘) [x(q, k, T), y(q, k, T)]=[x(r, k+1, Tb), y(r, k+1, Tb)].
PROOF. From η(q, Tk)=(r, b, R), it follows that x(r, k+1, Tb)=Tk+1 Tk+2·Tk+3 Tk+4 . . .
The x coordinate of




  
    
      
        
          
            G
            
              (
              
                
                  ⌊
                  x
                  ⌋
                
                ,
                
                  ⌊
                  y
                  ⌋
                
              
              )
            
          
          ⁡
          
            [
            
              
                x
                ⁡
                
                  (
                  
                    q
                    ,
                    k
                    ,
                    T
                  
                  )
                
              
              ,
              
                y
                ⁡
                
                  (
                  
                    q
                    ,
                    k
                    ,
                    T
                  
                  )
                
              
            
            ]
          
        
        =
        
        ⁢
        
          
            Bx
            ⁡
            
              (
              
                q
                ,
                k
                ,
                T
              
              )
            
          
          -
          
            
              B
              2
            
            ⁢
            
              v
              ⁡
              
                (
                a
                )
              
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            B
            (
            
              
                
                  aT
                  
                    k
                    +
                    1
                  
                
                ·
                
                  T
                  
                    k
                    +
                    2
                  
                
              
              ⁢
              
                T
                
                  k
                  +
                  3
                
              
              ⁢
              
                T
                
                  k
                  +
                  4
                
              
              ⁢
              
                
              
              ⁢
              ...
            
            ⁢
            
              
            
            )
          
          -
          
            
              B
              2
            
            ⁢
            
              v
              ⁡
              
                (
                a
                )
              
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            
              aT
              
                k
                +
                1
              
            
            ⁢
            
              
                T
                
                  k
                  +
                  2
                
              
              ·
              
                T
                
                  k
                  +
                  3
                
              
            
            ⁢
            
              T
              
                k
                +
                4
              
            
            ⁢
            
              
            
            ⁢
            ...
          
          ⁢
          
            
          
          -
          
            
              B
              2
            
            ⁢
            
              v
              ⁡
              
                (
                a
                )
              
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            T
            
              k
              +
              1
            
          
          ⁢
          
            
              T
              
                k
                +
                2
              
            
            ·
            
              T
              
                k
                +
                3
              
            
          
          ⁢
          
            T
            
              k
              +
              4
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          x
          ⁡
          
            (
            
              r
              ,
              
                k
                +
                1
              
              ,
              
                T
                b
              
            
            )
          
        
      
    
  




From η(q, Tk)=(r, b, R), it follows that y(r, k+1, Tb)=rb·Tk−1Tk−2Tk−3 . . .
The y coordinate of




  
    
      
        
          
            G
            
              (
              
                
                  ⌊
                  x
                  ⌋
                
                ,
                
                  ⌊
                  y
                  ⌋
                
              
              )
            
          
          ⁡
          
            [
            
              
                x
                ⁡
                
                  (
                  
                    q
                    ,
                    k
                    ,
                    T
                  
                  )
                
              
              ,
              
                y
                ⁡
                
                  (
                  
                    q
                    ,
                    k
                    ,
                    T
                  
                  )
                
              
            
            ]
          
        
        =
        
        ⁢
        
          
            
              B
              
                -
                1
              
            
            ⁢
            
              y
              ⁡
              
                (
                
                  q
                  ,
                  k
                  ,
                  T
                
                )
              
            
          
          +
          
            Bv
            ⁡
            
              (
              r
              )
            
          
          +
          
            v
            ⁡
            
              (
              b
              )
            
          
          -
          
            v
            ⁡
            
              (
              q
              )
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            
              B
              
                -
                1
              
            
            (
            
              
                
                  qT
                  
                    k
                    -
                    1
                  
                
                ·
                
                  T
                  
                    k
                    -
                    2
                  
                
              
              ⁢
              
                T
                
                  k
                  -
                  3
                
              
              ⁢
              
                
              
              ⁢
              ...
            
            ⁢
            
              
            
            )
          
          +
          
            Bv
            ⁡
            
              (
              r
              )
            
          
          +
        
      
    
  
  
    
      
        
        ⁢
        
          
            v
            ⁡
            
              (
              b
              )
            
          
          -
          
            v
            ⁡
            
              (
              q
              )
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            
              q
              ·
              
                T
                
                  k
                  -
                  1
                
              
            
            ⁢
            
              T
              
                k
                -
                2
              
            
            ⁢
            
              T
              
                k
                -
                3
              
            
            ⁢
            
              
            
            ⁢
            ...
          
          +
          
            Bv
            ⁡
            
              (
              r
              )
            
          
          +
          
            v
            ⁡
            
              (
              b
              )
            
          
          -
          
            v
            ⁡
            
              (
              q
              )
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            rb
            ·
            
              T
              
                k
                -
                1
              
            
          
          ⁢
          
            T
            
              k
              -
              2
            
          
          ⁢
          
            T
            
              k
              -
              3
            
          
          ⁢
          
            
          
          ⁢
          ...
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            y
            ⁡
            
              (
              
                r
                ,
                
                  k
                  +
                  1
                
                ,
                
                  T
                  b
                
              
              )
            
          
          .
        
      
    
  




Remark 2.21 Minimum vertical translation for right affine function First,



  
    
      
      
        
          v
          ⁡
          
            (
            β
            )
          
        
        -
        
          v
          ⁡
          
            (
            q
            )
          
        
      
      
    
    ≤
    
      B
      -
      1.
    
  




  
    
      
        
          
            
            n
            
          
          =
          
          ⁢
          
            
            
              
                Bv
                ⁡
                
                  (
                  r
                  )
                
              
              +
              
                v
                ⁡
                
                  (
                  β
                  )
                
              
              -
              
                v
                ⁡
                
                  (
                  q
                  )
                
              
            
            
          
        
      
    
    
      
        
          ≥
          
          ⁢
          
            
              Bv
              ⁡
              
                (
                r
                )
              
            
            -
            
              (
              
                B
                -
                1
              
              )
            
          
        
      
    
    
      
        
          ≥
          
          ⁢
          
            (
            
              
                
                A
                
              
              +
              
                1
                ⁢
                B
              
              -
              
                (
                
                  B
                  -
                  1
                
                )
              
            
          
        
      
    
  




  because




  
    
      
        
          
            v
            ⁡
            
              (
              r
              )
            
          
          ≥
          
          ⁢
          
            
              
              A
              
            
            +
            1
          
        
      
    
    
      
        
          =
          
          ⁢
          
            
              
                
                A
                
              
              ⁢
              B
            
            +
            1.
          
        
      
    
  



Thus, |n|≧|A|B+1.

Definition 2.22 Function Index Sequence and Function Sequence
Let {ƒ1, ƒ2, . . . , ƒI} be a set of functions such that each function ƒk: X→X. Then a function index sequence is a function S: N→{1, 2, . . . I} that indicates the order in which the functions {ƒ1, ƒ2, . . . , ƒI} are applied. If p is a point in X, then the orbit with respect to this function index sequence is [p, ƒS(1)(p), ƒS(2),ƒS(1)(p), . . . , ƒS(m)ƒS(m−1) . . . ƒS(2)ƒS(1)(p), . . . ]. Square brackets indicate that the order matters. Sometimes the first few functions will be listed in a function sequence when it is periodic. For example, [ƒ0, ƒ1, ƒ0, ƒ1, . . . ] is written when formally this function index sequence is S: N→{0, 1} where S(n)=n mod 2.
Example 2.23




  
    f
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              
                1
                4
              
            
            
              0
            
          
          
            
              0
            
            
              4
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            4
          
        
        
          
            0
          
        
      
      )
    
  




on domain U(0, 0) and





  
    g
    ⁡
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  =
  
    
      
        (
        
          
            
              
                1
                4
              
            
            
              0
            
          
          
            
              0
            
            
              4
            
          
        
        )
      
      ⁢
      
        (
        
          
            
              x
            
          
          
            
              y
            
          
        
        )
      
    
    +
    
      (
      
        
          
            
              -
              1
            
          
        
        
          
            0
          
        
      
      )
    
  




on U(4, 0)




  
    
      g
      ∘
      
        f
        ⁡
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
    
    =
    
      
        
          (
          
            
              
                
                  1
                  16
                
              
              
                0
              
            
            
              
                0
              
              
                16
              
            
          
          )
        
        ⁢
        
          (
          
            
              
                x
              
            
            
              
                y
              
            
          
          )
        
      
      +
      
        
          (
          
            
              
                0
              
            
            
              
                0
              
            
          
          )
        
        ⁢
        
          
        
        ⁢
        and
      
    
  




  
    
      
        
          
            f
            ⁡
            
              (
              
                
                  
                    0
                  
                
                
                  
                    0
                  
                
              
              )
            
          
          =
          
            (
            
              
                
                  4
                
              
              
                
                  0
                
              
            
            )
          
        
      
      
        
          
            f
            ⁡
            
              (
              
                
                  
                    1
                  
                
                
                  
                    0
                  
                
              
              )
            
          
          =
          
            (
            
              
                
                  4.25
                
              
              
                
                  0
                
              
            
            )
          
        
      
      
        
          
            f
            ⁡
            
              (
              
                
                  
                    0
                  
                
                
                  
                    1
                  
                
              
              )
            
          
          =
          
            (
            
              
                
                  4
                
              
              
                
                  1
                
              
            
            )
          
        
      
    
  



(0, 0) is a fixed point of gƒ. The orbit of point p chosen from the horizontal segment connected by the points (0, 0) and (1,0) with respect to the function sequence [ƒ, g, ƒ, g, . . . ] is a subset of U(0, 0)∪U(4, 0). The point p is called an immortal point. The orbit of a point Q outside this segment exits (halts) U(0,0)∪U(4, 0).

Definition 2.24 Halting and Immortal Orbits in the Plane.
Let P denote the two dimensional x,y plane. Suppose ƒk: Uk→P is a function for each k such that whenever j≠k, then Uj∩Uk=Ø. For any point p in the plane P an orbit may be generated as follows. The 0th iterate of the orbit is p. Given the kth iterate of the orbit is point q, if point q does not lie in any Uk, then the orbit halts. Otherwise, q lies in at least one Uj. Inductively, the k+1 iterate of q is defined as ƒj(q). If p has an orbit that never halts, this orbit is called an immortal orbit and p is called an immortal point. If p has an orbit that halts, this orbit is called a halting orbit and p is called a halting point.
Theorem 2.25 Turing Machine ExecutionAffine Map Orbit Halting/Immortal Orbit Correspondence Theorem
Consider Turing machine (Q, A, η) with initial tape configuration (s, 0, T). W.L.O.G., it is assumed that the machine begins executing with the tape head at zero. Let ƒ1, ƒ2, . . . , ƒI denote the I affine functions with corresponding unit square domains W1, W2, W3, . . . , Wi determined from 2.14, 2.15, 2.16 and 2.19. Let p=(x(s, 0, T), y(s, 0, T). Then from 2.14,




  
    x
    ⁡
    
      (
      
        s
        ,
        0
        ,
        T
      
      )
    
  
  =
  
    
      Bv
      ⁡
      
        (
        
          T
          0
        
        )
      
    
    +
    
      v
      ⁡
      
        (
        
          T
          1
        
        )
      
    
    +
    
      
        ∑
        
          j
          =
          1
        
        ∝
      
      ⁢
      
        
          v
          ⁡
          
            (
            
              T
              
                j
                +
                1
              
            
            )
          
        
        ⁢
        
          
            B
            
              -
              j
            
          
          .
        
      
    
  




Also,





  
    y
    ⁡
    
      (
      
        s
        ,
        0
        ,
        T
      
      )
    
  
  =
  
    
      Bv
      ⁡
      
        (
        s
        )
      
    
    +
    
      v
      ⁡
      
        (
        
          T
          
            -
            1
          
        
        )
      
    
    +
    
      
        ∑
        
          j
          =
          1
        
        ∝
      
      ⁢
      
        
          v
          ⁡
          
            (
            
              T
              
                
                  -
                  j
                
                -
                1
              
            
            )
          
        
        ⁢
        
          
            B
            
              -
              j
            
          
          .
        
      
    
  




There is a 1 to 1 correspondence between the mth point of the orbit





  
    [
    
      p
      ,
      
        
          f
          
            S
            ⁡
            
              (
              1
              )
            
          
        
        ⁡
        
          (
          p
          )
        
      
      ,
      
        
          f
          
            S
            ⁡
            
              (
              2
              )
            
          
        
        ⁢
        
          
            f
            
              S
              ⁡
              
                (
                1
                )
              
            
          
          ⁡
          
            (
            p
            )
          
        
      
      ,
      ...
      ⁢
      
        
      
      ,
      
        
          f
          
            S
            ⁡
            
              (
              m
              )
            
          
        
        ⁢
        
          f
          
            S
            ⁡
            
              (
              
                m
                -
                1
              
              )
            
          
        
        ⁢
        
          
        
        ⁢
        ...
        ⁢
        
          
        
        ⁢
        
          f
          
            S
            ⁡
            
              (
              2
              )
            
          
        
        ⁢
        
          
            f
            
              S
              ⁡
              
                (
                1
                )
              
            
          
          ⁡
          
            (
            p
            )
          
        
      
      ,
      ...
    
    ⁢
    
      
    
    ]
  
  ⊆
  
    
      ⋃
      
        k
        =
        1
      
      I
    
    ⁢
    
      W
      k
    
  




and the mth computational step of the Turing machine (Q, A, η) with initial configuration (s, 0, T). In particular, the Turing Machine halts on initial configuration (s, 0, T) if and only if p is a halting point with respect to affine functions ƒk: Wk→P where 1≦k≦I. Dually, the Turing Machine is immortal on initial configuration (s, 0, T) if and only if p is an immortal point with respect to affine functions ƒk: Wk→P where 1≦k≧I.

PROOF. From lemmas 2.17, 2.20, definition 2.14 and remark 2.15, every computational step of (Q, A, η) on current configuration (q, k, T′) corresponds to the application of one of the unique affine maps ƒk, uniquely determined by remark 2.15 and definitions 2.16, 2.19 on the corresponding point p=[x(r, k, T′), y(r, k, T′)]. Thus by induction, the correspondence holds for all n if the initial configuration (s, 0, T) is an immortal configuration which implies that [x(s, 0, T), y(s, 0, T)] is an immortal point. Similarly, if the initial configuration (s, 0, T) is a halting configuration, then the machine (Q, A, η) on (s, 0, T) halts after N computational steps. For each step, the correspondence implies that the orbit of initial point p0=[x(s, 0, T), y(s, 0, T)] exits




  
    ⋃
    
      k
      =
      1
    
    I
  
  ⁢
  
    W
    k
  




on the Nth iteration of the orbit. Thus, p0 is a halting point.

Corollary 2.26 Immortal Periodic Points, Induced by Configurations, Correspond to Equivalent Configurations that are Immortal Periodic.
PROOF. Suppose p=[x(q, k, T), y(q, k, T)] with respect to (Q, A, η) and p lies in




  
    ⋃
    
      k
      =
      1
    
    I
  
  ⁢
  
    W
    k
  




such that ƒS(N)ƒS(N−1) . . . ƒS(1)(p)=p. Starting with configuration (q, k, T), after N execution steps of (Q, A, η), the resulting configuration (q, j, V) satisfies x(q, k, T)=x(q, j, V) and y(q, k, T)=y(q, j, V) because of ƒS(N)ƒS(N−1) . . . ƒS(1)(p)=p and Theorem 2.25. This implies that (q, k, T) is translation equivalent to (q, j, V).

By induction this argument may be repeated indefinitely. Thus, (q, k, T) is an immortal configuration such that for every N computational steps of (Q, A, η), the kth resulting configuration (q, jk, Vk) is translation equivalent to (q, k, T).
Corollary 2.27 Immortal Periodic Points, Induced by Configurations, Correspond to Equivalent Configurations that are Immortal Periodic.
PROOF. Suppose p=[x(q, k, T), y(q, k, T)] with respect to (Q, A, η) and p lies in




  
    ⋃
    
      k
      =
      1
    
    I
  
  ⁢
  
    W
    k
  




such that ƒS(N)ƒS(N−1) . . . ƒS(1)(p)=p. Starting with configuration (q, k, T), after N execution steps of (Q, A, η), the resulting configuration (q, j, V) satisfies x(q, k, T)=x(q, j, V) and y(q, k, T)=y(q, j, V) because of ƒS(N)ƒS(N−1) . . . ƒS(1)(p)=p and Theorem 2.25. This implies that (q, k, T) is translation equivalent to (q, j, V).

By induction this argument may be repeated indefinitely. Thus, (q, k, T) is an immortal configuration such that for every N computational steps of (Q, A, η), the kth resulting configuration (q, jk, Vk) is translation equivalent to (q, k, T).
Lemma 2.28 Two affine functions with adjacent unit squares as their respective domains are either both right affine or both left affine functions. (Adjacent unit squares have lower left x and y coordinates that differ at most by 1. It is assumed that |Q|≧2, since any Turing program with only one state has a trivial halting behavior that can be determined in |A| execution steps when the tape is bounded.)
PROOF. The unit square U(└x┘, └y┘) has a lower left corner with coordinates (└x┘, └y┘) where └x┘=Bv(Tk)+v(Tk+1) and └y┘=Bv(q)+v(Tk−1). A left or right affine function (left or right move) is determined by the state q and the current tape square Tk. If states q≠r, then |Bv(q)−Bv(r)|≧B. If two alphabet symbols a, b are distinct, then |v(a)−v(b)|<|A|.
Thus, if two distinct program instructions have different states q≠r, then the corresponding unit squares have y-coordinates that differ by at least B−|A|=|Q|≧2, since any Turing program with just one state has trivial behavior that can be determined in |A| execution steps when the tape is bounded. Otherwise, two distinct program instructions must have distinct symbols at Tk. In this case, the corresponding unit squares have x-coordinates that differ by at least B−|A|=|Q|≧2.
Definition 2.29 Rationally Bounded Coordinates
Let ƒ1, ƒ2, . . . , ƒI denote the I affine functions with corresponding unit square domains W1, W2, . . . , WI. Let p be a point in the plane P with orbit [p, ƒS(1)(p), ƒS(2)ƒS(1)(p), . . . , ƒS(m)ƒS(m−1) . . . ƒS(2)ƒS(1)(p), . . . ]. The orbit of p has rationally bounded coordinates if conditions I & II hold.
I) For every point in the orbit z=fS(k)ƒS(k−1) . . . ƒS(2)ƒS(1)(p) the x-coordinate of z, x(z), and the y-coordinate of z, y(z), are both rational numbers.
II) There exists a natural number M such that for every point




  z
  =
  
    (
    
      
        
          p
          1
        
        
          q
          1
        
      
      ,
      
        
          p
          2
        
        
          q
          2
        
      
    
    )
  




in the orbit, where p1, p2, q1, and q2 are integers in reduced form, then |p1|<M, |p2|<M, |q1|<M, and |q2|<M.

An orbit is rationally unbounded if the orbit does not have rationally bounded coordinates.
Theorem 2.30 An Orbit with Rationally Bounded Coordinates is Periodic or Halting.
Proof. Suppose both coordinates are rationally bounded for the whole orbit and M is the natural number. If the orbit is halting we are done. Otherwise, the orbit is immortal. Since there are less than 2 M integer values for each one of p1, p2, q1 and q2 to hold, then the immortal orbit has to return to a point that it was already at. Thus it is periodic.
Corollary 2.31 A Turing machine execution whose tape head location is unbounded over the whole program execution corresponds to an immortal orbit.
Theorem 2.32 Suppose the initial tape contents is bounded as defined in definition 2.2. Then an orbit with rationally unbounded coordinates is an immortal orbit that is not periodic.
PROOF. If the orbit halts, then the orbit has a finite number of points. Thus, it must be an immortal orbit. This orbit is not periodic because the coordinates are rationally unbounded.
Corollary 2.33 If the Turing Machine execution is unbounded on the right half of the tape, then in regard to the corresponding affine orbit, there is a subsequence S(1), S(2), . . . , S(k), . . . of the indices of the function sequence g1, g2, . . . , gk, . . . such that for each natural number n the composition of functions gS(n)gS(n−1) . . . gS(1) iterated up to the s(n)th orbit point is of the form




  
    
      (
      
        
          
            
              B
              n
            
          
          
            0
          
        
        
          
            0
          
          
            
              1
              
                B
                n
              
            
          
        
      
      )
    
    ⁢
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  +
  
    (
    
      
        
          
            m
            
              s
              ⁡
              
                (
                n
                )
              
            
          
        
      
      
        
          
            t
            
              s
              ⁡
              
                (
                n
                )
              
            
          
        
      
    
    )
  




where ms(n), ts(n) are rational numbers.

Corollary 2.34 If the Turing Machine execution is unbounded on the left half of the tape, then in regard to the corresponding affine orbit, there is a subsequence S(1), S(2), . . . , S(k), . . . of the indices of the function sequence g1, g2, . . . , gk, . . . such that for each natural number n the composition of functions gS(n)gS(n−1) . . . gS(1) iterated up to the s(n)th orbit point is of the form:




  
    
      (
      
        
          
            
              1
              
                B
                n
              
            
          
          
            0
          
        
        
          
            0
          
          
            
              B
              n
            
          
        
      
      )
    
    ⁢
    
      (
      
        
          
            x
          
        
        
          
            y
          
        
      
      )
    
  
  +
  
    (
    
      
        
          
            m
            
              s
              ⁡
              
                (
                n
                )
              
            
          
        
      
      
        
          
            t
            
              s
              ⁡
              
                (
                n
                )
              
            
          
        
      
    
    )
  




where ms(n), ts(n) are rational numbers.

Theorem 2.35 M-Bounded Execution Implies a Halting or Periodic Orbit
Suppose that the Turing Machine (Q, A, η) begins or continues execution with a configuration such that its tape head location is M-bounded during the next (2M+1)|Q∥A|2M+1+1 execution steps. Then the Turing Machine program halts in at most (2M+1)|Q∥A|2M+1+1 execution steps or its corresponding orbit is periodic with period less than or equal to (2M+1)|Q∥A|2M+1+1.
PROOF. If the program halts in (2M+1)∥Q∥A|2M+1+1 steps, then the proof is completed. Otherwise, consider the first (2M+1)|Q∥A|2M+1+1 steps. There are a maximum of |Q∥A| program commands for each tape head location. There are a maximum of (2M+1) tape head locations. For each of the remaining 2M tape squares, each square can have at most |A| different symbols, which means a total of |A|2M possibilities for these tape squares. Thus, in the first (2M+1)|Q∥A|2M+1+1 points of the corresponding orbit in P, there are at most distinct (2M+1)|Q∥A|2M+1 points so at least one point in the orbit must occur more than once.
Prime Edge Complexity, Periodic Points & Repeating State Cycles
Definition 3.1 Overlap Matching & Intersection Patterns
The notion of an overlap match expresses how a part or all of one pattern may match part or all of another pattern. Let V and W be patterns. (V, s) overlap matches (W, t) if and only if V(s+c)=W(t+c) for each integer c satisfying λ≦c≦μ such that λ=min{s, t} and μ=min{|V|−1−s, |W|−1−t} where 0≦s<|V| and 0≦t<|W|. The index s is called the head of pattern V and t is called the head of pattern W. If V is also a subpattern, then (V, s) submatches (W, t).
If (V, s) overlap matches (W, t), then define the intersection pattern I with head u=λ as (I, u)=(V, s)∩(W, t), where I(c)=V(c+s−λ) for every integer c satisfying 0≦c≦(μ+λ) where λ=min {s, t} and μ=min {|V|−1−s, |W|−1−t}.
Definition 3.2 Edge Pattern Substitution Operator
Consider pattern V=v0 v1 . . . vn, pattern W=w0 w1 . . . wn with heads s, t satisfying 0≦s, t≦n and pattern P=p0 p1 . . . pm with head u satisfying 0≦u≦m. Suppose (P, u) overlap matches (V, s). Then define the edge pattern substitution operator ⊕ as E=(P, u)⊕[(v, s)(W, t)] according to the four different cases A., B., C. and D.
Case A.) u>s and m−u>n−s. See FIG. 24.




  
    E
    ⁡
    
      (
      k
      )
    
  
  =
  
    {
    
      
        
          
            W
            ⁡
            
              (
              
                k
                +
                s
                -
                u
              
              )
            
          
        
        
          when
        
        
          
            u
            ≤
            
              k
              +
              s
            
            ≤
            
              u
              +
              n
            
          
        
      
      
        
          
            P
            ⁡
            
              (
              k
              )
            
          
        
        
          
            
              when
              ⁢
              
                
              
              ⁢
              0
            
            ≤
            k
            <
            
              u
              -
              
                s
                ⁢
                
                  
                
                ⁢
                OR
              
            
          
        
        
          
            
              u
              +
              n
              -
              s
            
            <
            k
            ≤
            m
          
        
      
    
    }
  




where the head of E is u+t−s. Observe that |E|=m+1

Case B.) u>s and m−u≦n−s. See FIG. 25.




  
    E
    ⁡
    
      (
      k
      )
    
  
  =
  
    {
    
      
        
          
            W
            ⁡
            
              (
              
                k
                +
                s
                -
                u
              
              )
            
          
        
        
          when
        
        
          
            
              u
              -
              s
            
            ≤
            k
            ≤
            
              n
              +
              s
              -
              u
            
          
        
      
      
        
          
            P
            ⁡
            
              (
              k
              )
            
          
        
        
          when
        
        
          
            0
            ≤
            k
            <
            
              u
              -
              s
            
          
        
      
    
    }
  




where the head of E is u+t−s. Also, |E|=n+s−u+1
Case C.) u≦s and m−u<n−s. See FIG. 26.
E(k)=W(k) when 0≦k≦n and the head of E is t. Also, |E|=|W|=n+1.
Case D.) u≦s and m−u>n−s. See FIG. 27.




  
    E
    ⁡
    
      (
      k
      )
    
  
  =
  
    {
    
      
        
          
            W
            ⁡
            
              (
              
                k
                +
                u
                -
                s
              
              )
            
          
        
        
          when
        
        
          
            n
            <
            k
            ≤
            
              m
              +
              s
              -
              u
            
          
        
      
      
        
          
            W
            ⁡
            
              (
              k
              )
            
          
        
        
          when
        
        
          
            0
            ≤
            k
            ≤
            n
          
        
      
    
    }
  




where the head of E is t. Also, |E|=m+s−u+1

Overlap and intersection matching and edge pattern substitution are useful in searching for periodic points and in algorithms that execute all possible finite Turing machine configurations.
Example 3.3
Overlap Matching and Edge Substitution
Set pattern P=0101 110. Set pattern V=11 0101. Set pattern W=01 0010. Then (P, 0) overlap matches (V, 2). Edge pattern substitution is well-defined so E=(P, 0)⊕[(V, 2)(W, 4)]=01 0010 110. The head or index of pattern E=4. Also, (P, 4) overlap matches (V, 0). F=(P, 4)⊕[(V, 0)(W, 4)]=0101 010010. The index of pattern F=u+t−s=4+4−0=8.
Definition 3.4 State Cycle
Consider N execution steps of Turing Machine (Q, A, η). After each execution step, the machine is in some state qk and the tape head is pointing to some alphabet symbol ak. Relabeling the indices of the states and the alphabet symbols if necessary and assuming the machine has not halted after N execution steps in terms of the input commands is denoted as: (q0, a0)(q1, a1)  . . . (qN−1, aN−1)(qN, aN). A state cycle is a valid execution sequence of input commands such that the first and last input command in the sequence have the same state i.e. (qk, ak)(qk+1, ak+1) . . . (qN−1, aN−1)(qk, ak). The length of this state cycle equals the number of input commands minus one. A state cycle is called a prime state cycle if it contains no proper state subcycles. For a prime state cycle, the length of the cycle equals the number of distinct states in the sequence. For example, (2, 0)(3, 1)(4, 0)(2, 1) is called a prime 3-state cycle because it has length 3 and also 3 distinct states {2, 3, 4}.
Remark 3.5 any Prime State Cycle has Length ≦|Q|
This follows from the Dirichlet principle and the definition of a prime state cycle.
Remark 3.6 Maximum Number of Distinct Prime State Cycles
Given an alphabet A and states Q, consider an arbitrary prime state cycle with length 1, (q, a)(q, b). There are |Q∥A| choices for the first input command and |A| choices for the second input command since the states must match. Thus, there are |Q∥A|2 distinct prime state cycles with length 1. Similarly, consider a prime state cycle with window of execution whose length is 2, this can be represented as (q1, a1)(q2, a2)(q1, b1).
Then there are |Q∥A| choices for (q1, a1) and once (q1, a1) is chosen there is only one choice for q2 because it is completely determined by η(q1, a1)=(qz, b1) where n is the program in (Q, A, η). Similarly, there is only one choice for b1. There are |A| choices for a2. Thus, there are |Q∥A|2 distinct choices.
For an arbitrary prime state cycle (q1, a1)(qz, a2) . . . (qn, an)(q1, an+1) with window of execution of length k then there are |Q∥A| choices for (q1, a1) and |A| choices for a2 since the current window of execution length after the first step increases by 1. There is only one choice for q2 because it is determined by η(q1, a1). Similarly, for the jth computational step, if the current window of execution length increases by 1, then there are |A| choices for (qj+1, aj+1). Similarly, for the jth computational step, if the current window of execution stays unchanged, then there is only one choice for aj+1 that was determined by one of the previous j computational steps. Thus, there are at most |Q∥A|k distinct prime state cycles whose window of execution length equals k. Definitions 2.8 and remark 2.10 imply that a prime k-state cycle has a window of execution length less than or equal to k. Thus, from the previous and 3.5, there are at most




  
    
    Q
    
  
  ⁢
  
    
      ∑
      
        k
        =
        1
      
      
        
        Q
        
      
    
    ⁢
    
      
        
        A
        
      
      k
    
  




distinct prime state cycles in (Q, A, η).

Remark 3.7 any State Cycle Contains a Prime State Cycle
PROOF. Relabeling if necessary let S(q1, q1)=(q1, a1) . . . (qn, an)(q1, an+1) be a state cycle. If qi is the only state visited twice, then the proof is completed. Otherwise, define u=min{|S(qk, qk) S(qk, qk) is a subcycle of S(q1, q1)}. Then μ exists because S(q1, q1) is a subcycle of S(q1, q1). Claim: Any state cycle S(qj, qj) with |S(qj, qj)|=μ must be a prime state cycle. Suppose not. Then there is a state r≠qj that is visited twice in the state cycle S(qj, qj). But then S(qr, qr) is a cycle with length less than μ which contradicts μ's definition.
Definition 3.8 Consecutive Repeating State Cycle for (Q, A, η)
If machine (Q, A, η) starts execution and repeats a state cycle two consecutive times i.e. (q1, b1) . . . (qn, bn)(q1, b1) . . . (qn, bn)(q1, b1), then (Q, A, η) has a consecutive repeating state cycle.
Definition 3.9 Execution Node for (Q, A, η)
An execution node (or node) is a triplet Π=[q, w0 . . . wn, t] for some state q in Q where w0 w1 . . . wn is a pattern of n+1 alphabet symbols each in A such that t is a non-negative integer satisfying 0≦t≦n. Intuitively, w0 w1 . . . wn is the pattern of alphabet symbols on n+1 consecutive tape squares on the tape and t represents the location of the tape head.
Lemma 3.10 Every Immortal Periodic Point Induces a Consecutive Repeating State Cycle.
PROOF. Suppose p is an immortal periodic point with period n. Then by the Turing-Affine correspondence theorem the kth iterate of p is ƒS(k) ƒS(k−1) . . . ƒS(1)(p) and the application of affine function ƒS(k) corresponds to the execution of input command (qk, bk). Thus, let the input command sequence (q1, b1) . . . (qn, bn)(qn+1, bn+1) denote the first n input commands that are executed. Since p has period n, ƒS(n) . . . ƒS(k) . . . ƒS(1)(p)=p. Thus, (q1, b1)=(qn+1, b+1). Thus, the first n steps are a state cycle (q1, b1) . . . (qn, bn)(q1, b1). Since the n+1 computational step corresponds to applying ƒS(1) to p which corresponds to input command (q1, b1). By induction, the n+k computational step corresponds to applying function ƒS(k) to the point ƒS(k−1) . . . ƒS(1)(p) which by the previous paragraph corresponds to the execution of the input command (qk, bk). Thus, the sequence of input commands is (q1, b1) . . . (qn, bn)(q1, b1) . . . (qn, bn)(q1, b1).
Lemma 3.11 Every Consecutive Repeating State Cycle Induces an Immortal Periodic Orbit
Suppose Turing machine (Q, A, η) begins or resumes execution at some tape square and repeats a state cycle two consecutive times. Then (Q, A, η) has an immortal periodic point and this state cycle induces the immortal periodic point.
PROOF. Let the state cycle that is repeated two consecutive times be denoted as (q1, b1) . . . (qn, bn)(q1, b1) . . . (qn, bn)(q1, b1). Let sk denote the tape square right before input command (qk, bk) is executed the first time where 1≦k≦n. Let Tk denote the tape square right before input command (qk, bk) is executed the second time where 1≦k≦n.
Thus, the window of execution for the first repetition of the state cycle, right before input command (q1, b1) is executed a second time, denoted In={s1, s2, . . . sk, sk+1 . . . sn, sn+1} where sn+1=t1. The window of execution for the second repetition of the state cycle is Jn={t1, t2, . . . , tn, tn+1} where tn+1=tn+t1−sn.
Furthermore, observe that the window of execution for the computational steps 1 thru k is Ik={s1, s2, . . . sk, sk+1} where the tape square sk+1 is indicated after input command (qk, bk) is executed the first time. Also, observe that the window of execution for the computational steps n+1 thru n+k is Jk={t1, t2, . . . , tk, tk+1} where the tape square Tk+1 is indicated after the input command (qk, bk) is executed the second time (in the second repeating cycle).
Next a useful notation represents the tape patterns for each computational step. Then the proof is completed using induction.
Let V1 denote the tape pattern—which is the sequence of alphabet symbols in the tape squares over the window of execution In—right before input command (q1, b1) is executed the first time. Thus, V1(s1)=b1. Let Vk denote the tape pattern—which is the sequence of alphabet symbols in the tape squares over the window of execution In—right before input command (qk, bk) is executed the first time. Thus, Vk(sk)=bk.
Let W1 denote the tape pattern—which is the sequence of alphabet symbols in the tape squares over the window of execution Jn—right before input command (q1, b1) is executed the second time. Thus, W1(t1)=b1. Let Wk denote the tape pattern—which is the sequence of alphabet symbols in the tape squares over the window of execution Jn—right before input command (qk, bk) is executed the second time. Thus, Wk(tk)=bk.
Using induction, it is shown that V1 on window of execution In equals W1 on window of execution Jn. This completes the proof.
Since (q1, b1) is the input command before computational step 1 and (q1, b1) is the input command before computational step n+1, then V1(s1)=b1=W1(t1). Thus, V1 restricted to window of execution I1 equals W1 restricted to window of execution J1.
From the definition, η(q1, b1)=η(q2, a1, x) for some a1 in A and where x equals L or R. Note that L represents a left tape head move and R a right tape head move.
Case x=R. A right tape head move.




Then s2=s1+1, t2=t1+1 and V1(s2)=b2=W1(t2). It has already been observed that V1(s1)=b1=W1(t1). Thus, V1 restricted to the window of execution I2 equals W1 restricted on the window of execution J2 Furthermore, the tape head is at s1 right before computational step 1 and input command (q1, b1) is executed; the tape head is at t1 right before computational step n+1 and input command (q1, b1) is executed.
Also, V2(s1)=a1=W2(t1) and V2(s2)=b2=W2(t2). Thus, V2 restricted to the window of execution I2 equals W2 restricted to the window of execution J2 Furthermore, the tape head is at s2 right before computational step 2 with input command (q2, b2) is executed; the tape head is at t2 right before computational step n+2 with input command (q2, b2) is executed.
Case x=L. A left tape head move.




Then s2=s1−1, t2=t1−1 and V1(s2)=b2=W1(t2). And V1(s1)=b1=W1(t1). Thus, V1 restricted to the window of execution I2 equals W1 restricted on the window of execution J2. Furthermore, the tape head is at s1 right before computational step 1 and input command (q1, b1) is executed; the tape head is at t1 right before computational step n+1 and input command (q1, b1) is executed.
Also, V2(s1)=a1=W2(t1) and V2(s2)=b2=W2(t2). Thus, V2 restricted to the window of execution I2 equals W2 restricted to the window of execution J2 Furthermore, the tape head is at s2 right before computational step 2 and input command (q2, b2) is executed; the tape head is at t2 right before computational step n+2 and input command (q2, b2) is executed. This completes the base case of induction.
Induction Hypothesis.
Suppose that for the 1, 2, . . . , k−1 computational steps and the corresponding n+1, n+2, . . . , n+k−1 steps that for every i with 1≦i≦k
V1 restricted to the window of execution Ii equals W1 restricted on the window of execution Ji; V2 restricted to the window of execution Ii equals W2 restricted on the window of execution Ji; and . . . Vi restricted to the window of execution Ii equals Wi restricted on the window of execution Ji.
Furthermore, the tape head is at si right before computational step i and input command (qi, bi) is executed; the tape head is at ti right before computational step n+i and input command (qi, bi) is executed.
Induction Step.
Since (qk, bk) is the input command before computational step k and before computational step n+k, then Vk(sk)=bk=Wk(tk).
From the definition, η(qk, bk)=η(qk+1, ak, x) for some ak in A and x equals L or R. Note that L represents a left tape head move and R a right tape head move.
Case x=R. A right tape head move for computational steps k and n+k.




By the inductive hypothesis Vk restricted to window of execution Ik equals Wk restricted to window of execution Jk and the only change to the tape and tape head after executing η(qk, bk)=η(qk+1, ak, R) for the steps k and n+k is that Vk+1(sk)=ak=Wk+1(tk) and Vk+1(sk+1)=bk+1=Wk+1(tk+1) and that the tape heads move right to sk+1 and Tk+1 respectively.
Thus, Vk+1 restricted to the window of execution Ik+1 equals Wk+1 restricted on the window of execution Jk+1. And for each j satisfying 1≦j≦k, then Vj restricted to the window of execution Ik+1 equals Wj restricted on the window of execution Jk+1.
Case x=L. A left tape head move for computational steps k and n+k.




By the inductive hypothesis Vk restricted to window of execution Ik equals Wk restricted to window of execution Jk and the only change to the tape and tape head after executing η(qk, bk)=η(qk+1, ak, L) for the steps k and n+k is that Vk+1(sk)=ak=Wk+1(tk) and Vk+1(Sk+1)=bk+1=Wk+1(tk+1) and that the tape heads move left to sk+1 and Tk+1 respectively.
Thus, Vk+1 restricted to the window of execution Ik+1 equals Wk+1 restricted on the window of execution Jk+1. And for each j satisfying 1≦j≦k, then Vj restricted to the window of execution Ik+1 equals Wj restricted on the window of execution Jk+1.
Prime Directed Sequences & Periodic Point Search
Definition 4.1 Prime Directed Edge from Head and Tail Execution Nodes
A prime head execution node Δ=[q, v0 v1 . . . vn, s] and prime tail execution node=[r, w0 w1 . . . wn, t] are called a prime directed edge if and only if all of the following hold:

    
    
        When Turing machine (Q, A, η) starts execution, it is in state q; the tape head is located at tape square s. For each j satisfying 0≦j≦n tape square j contains symbol vj. In other words, the initial tape pattern is v0 v1 . . . vs . . . vn.
        During the next N computational steps, state r is visited twice and all other states in Q are visited at most once. In other words, the corresponding sequence of input commands during the N computational steps executed contains only one prime state cycle.
        After N computational steps, where 1≦N≦|Q|, the machine is in state r. The tape head is located at tape square t. For each j satisfying 0≦j≦n tape square j contains symbol wj. The tape pattern after the N computational steps is w0 w1 . . . wt . . . wn.
        The window of execution for these N computational steps is [0, n].
    
    


A prime directed edge is denoted as ΔΓ or [q, v0 v1 . . . vn, s][r, w0 w1 . . . t]. The number of computational steps N is denoted as |ΔΓ|.
Definition 4.2 Prime Input Command Sequence
3.4 introduced input commands. If (q1, a1) . . . (qn, an) is an execution sequence of input commands for (Q, A, η), then (q1, a1) . . . (qn, an) is a prime input command sequence if qn is visited twice and all other states in the sequence are visited once. In other words, a prime input command sequence contains exactly one prime state cycle.
Notation 4.3 Prime Input Command Sequence Notation
Using the same notation as lemma 3.11, let V1 denote the initial tape pattern—which is the sequence of alphabet symbols in the tape squares over the window of execution of the prime input command sequence—right before the first input command (q1, a1) in the sequence is executed. And let s1 denote the location of the tape head i.e. V1(s1)=a1. Let Vk denote the tape pattern right before the kth input command (qk, ak) in the sequence is executed and let sk denote the location of the tape head i.e. Vk(sk)=ak.
Definition 4.4 Composition of Prime Input Command Sequences
Let (q1, a1) . . . (qn, an) and (r1, b1) . . . (rm, bm) be prime input command sequences where Vk denotes the tape pattern right before the kth input command (qk, ak) with tape head at sk with respect to Vk and Wk denotes the tape pattern right before the kth input command (rk, bk) with tape head at tk with respect to Wk.
Suppose (Vn, sn) overlap matches with (W1, t1) and qn=r1. Then (qn, an)=(r1, b1). And the composition of these two prime input command sequences is defined as (q1, ai)  . . . (qn, an)(r2, b2) . . . (rm, bm). The composition is undefined if (Vn, sn) and (W1, t1) do not overlap match or qn≠r1.
If (q1, a1) . . . (qn, an)(q1, b1) is a prime state cycle, then it is also prime input command sequence. For simplicity in upcoming lemma 4.15, it is called a composition of one prime input command sequence.
The purpose of these next group of definitions is to show that any consecutive repeating state cycle is contained inside a composition of prime input command sequences. From lemmas 3.10 and 3.11, there is a one to one correspondence between a consecutive repeating state cycle and an immortal periodic point.
If this consecutive repeating state cycle is rotated, then it is still part of the same periodic orbit of the original periodic point. Next it is shown that there is a one to one correspondence between prime input command sequences and prime directed edges. Subsequently, it is explained how to link match prime directed edges. Then it is demonstrated how to find all prime directed edges for a particular Turing machine or a digital computer program. If a particular Turing machine (digital computer program) has any immortal periodic points, then it will have corresponding consecutive repeating state cycles which will be contained in an edge sequence of prime directed edges that are link matched.
Example 4.5
Directed Partition Method
Start with the finite sequence (0, 4, 2, 3, 4, 1, 3, 0, 1, 2, 0, 4, 2, 3, 4, 1, 3, 0, 1, 2).










Partition Steps

















(0 4 2 3 4 1 3 0 1 2 0 4 2 3 4 1 3 0 1 2)












( (0 4 2 3) 4 1 3 0 1 2 0 4 2 3 4 1 3 0 1 2)
4 lies in (0 4 2 3).
1st
element found.


( (0 4 2 3) (4 1 3 0) 1 2 0 4 2 3 4 1 3 0 1 2)
1 lies in (4 1 3 0).
2nd
element found.


( (0 4 2 3) (4 1 3 0) (1 2 0 4) 2 3 4 1 3 0 1 2)
2 lies in (1 2 0 4).
3rd
element found.


( (0 4 2 3) (4 1 3 0) (1 2 0 4) (2 3 4 1) 3 0 1 2)
3 lies in (2 3 4 1).
4th
element found.


( (0 4 2 3) (4 1 3 0) (1 2 0 4) (2 3 4 1) (3 0 1 2))
0 lies in (0 4 2 3).
5th
element found.









Definition 4.6 Tuples
A tuple is a finite sequence of objects denoted as (σ1, σ2, . . . σm). The length of the tuple is the number of objects in the sequence denoted as |(σ1, σ2, . . . , σm)|=m. For our purposes, the objects of the tuple may be states, input commands or natural numbers. (3) is a tuple of length one. (1, 4, 5, 6) is a tuple of length four. Sometimes the commas will be omitted as in the previous example. (4 6 0 1 2 3) is a tuple of length six. The 4 is called the first object in tuple (4 6 0 1 2 3). 1 is called a member of tuple (4 6 0 1 2 3).
Definition 4.7 Tuple of Tuples
A tuple of tuples is of the form (w1, w2, . . . , wn) where each wk may have a different length. An example of a tuple of tuples is ((3), (1, 4, 5, 6), (4, 5, 6)). Sometimes the commas are omitted: ((0 8 2 3) (1 7 5 7) (5 5 6)).
Definition 4.8 Directed Partition of a Sequence
A directed partition is a tuple of tuples (w1, w2, . . . , wn) that satisfies Rules A and B.

    
    
        Rule A. No object a occurs in any element tuple wk more than once.
        Rule B. If wk and wk+1 are consecutive tuples, then the first object in tuple wk+1 is a member of tuple Wk.
    
    


Example 4.9
Directed Partition Examples
((0 8 2 3) (8 7 5 4) (5 0 6)) is an example of a directed partition.
((0 8 2 3) (8 7 5 4) (5 0 6)) is sometimes called a partition tuple.
(0 8 2 3) is the first element tuple. And the first object in this element tuple is 0.
Element tuple (8 0 5 7 0 3) violates Rule A because object 0 occurs twice.
((0 8 2 3) (1 7 5 4) (5 0 6)) violates Rule B since 1 is not a member of element tuple (0 8 2 3).
Definition 4.10 Consecutive Repeating Sequence and Extensions
A consecutive repeating sequence is a sequence (x1, x2, . . . , xn, . . . , x2n) of length 2n for some positive integer n such that xk=xn+k for each k satisfying 1≦k≦n. An extension sequence is the same consecutive repeating sequence for the first 2n elements (x1 . . . xn . . . x2n . . . X2n+m) such that xk=x2n+k for each k satisfying 1≦k≦m.
A minimal extension sequence is an extension sequence (x1, . . . x2n+m) where m is the minimum positive number such that there is one element in x2n, x2n+1, . . . , x2n+m that occurs more than once. Thus, x2n+k=x2n+m for some k satisfying 0≦k<m.
For example, the sequence S=(4 2 3 4 1 3 0 1 2 0 4 2 3 4 1 3 0 1 2 0) is a consecutive repeating sequence and S=(4 2 3 4 1 3 0 1 2 0 4 2 3 4 1 3 0 1 2 0 4 2 3 4 1) is an extension sequence. S contains consecutive repeating sequence S.
Definition 4.11 Directed Partition Extension with Last Tuple Satisfying Rule B
Suppose (x1 . . . xn . . . x2n, x2n+1, . . . x2n+m) is an extension of consecutive repeating sequence (x1 . . . xn . . . X2n). Then (w1, w2, . . . , wr) is a directed partition extension if it is a directed partition of the extension: The last tuple wr satisfies Rule B if x2n+m is the last object in tuple wr and xm+1 lies in tuple wr.
For example, the extension S=(4 2 3 4 1 3 0 1 2 0 4 2 3 4 1 3 0 1 2 0 4 2 3) has directed partition extension ((4 2 3) (4 1 3 0) (1 2 0 4) (2 3 4 1) (3 0 1 2) (0 4 2 3)) and the last tuple satisfies Rule B since 4 lies in (0 4 2 3)
Method 4.12 Directed Partition Method












Given a finite sequence (x1 . . . xn) of objects.


Initialize element tuple w1 to the empty tuple, ( )


Initialize partition tuple P to the empty tuple, ( )


For each element xk in sequence (x1 . . . xn)


{









if xk is a member of the current element tuple wr



{









Append element tuple wr to the end of partition tuple so that



P = (w1 . . . wr)



Initialize current element tuple wr+1 = (xk)









 }



 else update wr by appending xk to end of element tuple wr







}


The final result is the current partition tuple P after element xn is


examined in the loop.


Observe that the tail of elements from (x1 . . . xn) with no repeated


elements will not lie in the last element tuple of the final result P.









Example 4.13
Directed Partition Method Implemented in newLISP, www.newlisp.org















(define (add_object element_tuple object)









(if (member object element_tuple) nil









 (append element_tuple (list object)) ))









(define (find_partition seq)









(let









( (partition_tuple ′( ) )









  (element_tuple ′( ) )



  (test_add nil)









)



(dolist (object seq)









(set ′test_add (add_object element_tuple object) )



(if test_add









(set ′element_tuple test_add)



(begin









(set ′partition_tuple









(append partition_tuple (list



element_tuple) ) )









(set ′element_tuple (list object) )









 ) ) )



 partition_tuple









))



(set ′seq ′(4234130120 4234130120 4234) )



> (find_partition seq)



( (423) (4130) (1204) (2341) (3012) (0423) )










4 lies in the last tuple (0 4 2 3)
Lemma 4.14 Every Consecutive Repeating Sequence has an Extension Sequence with a Directed Partition Such that the Last Tuple Satisfies the Rule B Property.
PROOF. As defined in 4.10, extend consecutive repeating sequence (x1, x2 . . . x2n) to the extension sequence (x1, x2 . . . x2n, x2n+1 . . . x2n+m) such that m is the minimum positive number such that there is one element in x2n, x2n+1 . . . X2n+m that occurs more than once. Thus, X2n+k=x2n+m for some k satisfying 0≦k<m.
Apply method 4.12 to S=(x1, x2 . . . x2n, x2n+1 . . . x2n+m). Then the resulting partition tuple P extends at least until element x2n and the last tuple in P satisfies rule B. If the partition tuple P is mapped back to the underlying sequence of elements, then it is an extension sequence since it reaches element x2n.
Lemma 4.15 any Consecutive Repeating State Cycle is Contained in a Composition of One or More Prime Input Command Sequences.
PROOF. Let σ=[(q1, a1) . . . (qn, an)(q1, a1) . . . (qn, an)] be a consecutive repeating cycle. Method 4.12 & 4.14 show that this sequence of consecutive repeating input commands may be extended to a minimal extension sequence: [(q1, a1) . . . (qn, an)(q1, a1) . . . (qn, an)(q1, a1) . . . (qm, am)]
For simplicity, let vk denote input command (qk, ak).
Apply method 4.12 to (v1, . . . vn v1 . . . vn v1 . . . vm) so that the result is the partition tuple P=(w1, . . . wr). Then the sequence of element tuples in P represent a composition of one or more prime input command sequences. Rules A and B imply that for consecutive tuples wk=(vk(1) vk(2) . . . vk(m)) and wk+1=(v(k+1)(1) v(k+1)(2) . . . v(k+1)(m)), then (qk(1), ak(1))(qk(2), ak(2)) . . . (qk(m), ak(m))(qk+1(1), a(k+1)(1)) is a prime input command sequence. And 4.14 implies that the last tuple wr corresponds to a prime input command sequence and that the consecutive repeating state cycle is contained in the partition P mapped back to the sequence of input commands.
Definition 4.16 Finite Sequence Rotation
Let (x0 x1 . . . xn) be a finite sequence. A k-rotation is the resulting sequence (xk xk+1 . . . xn x0 X1 . . . xk−1). The 3-rotation of (8 7 3 4 5) is (3 4 5 8 7). When it does matter how many elements it has been rotated, it is called a sequence rotation.
Definition 4.17 Rotating a State-Symbol Cycle
Let (q1, a1) . . . (qn, an)(q1, b1) be a state cycle. This state cycle is called a state-symbol cycle if a1=b1. A rotation of this state-symbol cycle is the state cycle (qk, ak) . . . (qn, an)(q1, a1) . . . (qk, ak) for some k satisfying 0≦k≦n. In this case, the state-symbol cycle has been rotated by k−1 steps.
Lemma 4.18 any Consecutive Repeating Rotated State Cycle Generated from a Consecutive Repeating State Cycle Induces the Same Immortal Periodic Orbit.
PROOF. Let p be the immortal periodic point induced by this consecutive repeating state cycle. Rotating this state cycle by k steps corresponds to iterating p by the next k corresponding affine functions.
Lemma 4.19 Prime Directed EdgesPrime Input Command Sequences
Prime directed edges and prime input command sequences are in 1 to 1 correspondence. PROOF. () Let ΔΓ be a prime directed edge where Δ=[q, v0 v1 . . . vn, s] and Γ=[r, w0 w1 . . . wn, t]. From the definition of a prime directed edge, over the next N computational steps some state r is visited twice, all other states in Q are visited at most once and there is a sequence of input commands (q, vs)(q1, a1 . . . (r, ak) . . . (r, wt) corresponding to these N steps. This is a prime input command sequence.
() Let (q1, a1) . . . (qn, an) be a prime input command sequence with N computational steps. Then qn is visited twice and all other states in the sequence are visited only once. Let v0 V1 . . . v, be the initial tape pattern over the window of execution during the N computational steps. Now a1=vs for some s. Let w0 w1 . . . wn be the final tape pattern over the window of execution as a result of these N steps. Then an=v, for some t. Thus, [q, v0 v1 . . . vn, s][r, w0 w1 . . . wn, t] is a prime directed edge.
Remark 4.20 Upper Bound for the Number of Prime Directed Edges
Each prime head node determines a unique prime directed edge so an upper bound for head nodes provides an upper bound for the number of distinct prime directed edges. Consider prime head node [q, V, s]. There are |Q| choices for the state q. Any pattern that represents the window of execution has length ≦|Q|+1. Furthermore, by the previous remark any pattern P such that (V, s) submatches (P, t) for some t, then the resultant pattern is the same since V spans the window of execution. Thus, |A||Q|+1 is an upper bound for the number of different patterns V.
Lastly, there are two choices for s in a |Q|+1 length pattern because the maximum number of execution steps is |Q| i.e. the tape head move sequence is L|Q| or R|Q|. Thus, |Q| is an upper bound for the number of choices for s unless |Q|=1. The following bound works in the trivial case that |Q|=1. Thus, there are at most |Q|2|A||Q|+1 prime directed edges.
Example 4.21
3-State Machine Prime Directed Edges and Prime Input Command Sequences
Consider Turing Machine (Q, A, η). Q={2, 3, 4} and 1 is the halting state. A={0, 1}. η is specified as follows. η(2, 0)=(3, 1, L). η(2, 1)=(4, 0, L). η(3, 0)=(4, 1, R). η(3, 1)=(4, 0, R). η(4, 0)=(1, 0, R). η(4, 1)=(2, 0, R).











Prime Directed Edges
Prime Input Command Sequences







[2, 000, 1]   [2, 100, 2]
(2, 0)   (3, 0)   (4, 1)   (2, 0)


[2, 100, 2]   [2, 000, 2] 
(2, 0)   (3, 1)   (4, 1)   (2, 0)


[2, 11, 1]   [2, 00, 1]
(2, 1)   (4, 1)   (2, 0)


[2, 001, 1]   [2, 101, 2]
(2, 0)   (3, 0)   (4, 1)   (2, 1)


[2, 101, 1]   [2, 001, 2]
(2, 0)   (3, 1)   (4, 1)   (2, 1)


[3, 010, 0]   [3, 101, 1]
(3, 0)   (4, 1)   (2, 0)   (3, 0)


[3, 110, 0]   [3, 001, 1]
(3, 1)   (4, 1)   (2, 0)   (3, 0)


[4, 10, 0]   [4, 11, 1]
(4, 1)   (2, 0)   (3, 0)   (4, 1)


[4, 11, 0]   [4, 00, 1]
(4, 1)   (2, 1)   (4, 0)









There are 9 distinct prime state cycles. Observe that |Q|2|A||Q|+1=32(42) 144.
Observe that |Q|(|A|+|A|2)=2(2+4)=12.
The upper bound in 4.20 is not sharp. Although sharp upper bounds for the number of prime directed edges can be important, the sharpness of the upper bounds does not affect the speed of method 4.34 in finding prime directed edges for a particular Turing machine.
In what follows prime directed edges are link matched so that for a given Turing Machine a method for finding consecutive repeating state cycles is demonstrated. It is proved that this method will find immortal periodic points if they exist.
Definition 4.22 Halting Execution Node
Suppose [q, v0 v1 . . . vn, s] is an execution node and over the next |Q| computational steps a prime state cycle is not found. In other words, a prime directed edge is not generated. Then the Turing machine execution halted in |Q| or less steps. Let W be a pattern such that (W, t) submatches (V, s) and W spans the window of execution until execution halts. Define the halting node as H=[q, W, t].
Definition 4.23 Prime Directed Edge Complexity
Remark 4.20 provides an upper bound on the number of prime directed edges. Let={Δ1Γ1, . . . , ΔkΓk, . . . , ΔNrN} denote the finite set of prime directed edges for machine (Q, A, η). Define the prime directed edge complexity of Turing machine (Q, A, η) to be the number of prime directed edges denoted as |P|.
Observe that any digital computer program also has a finite prime directed edge complexity. This follows from the fact that any digital computer program can be executed by a Turing machine.
Definition 4.24 Overlap Matching of a Node to a Prime Head Node Execution Node Π Overlap Matches Prime Head Node Δ if and Only if the Following Hold.

    
    
        Π=[r, w0 w1 . . . wn, t] is an execution node satisfying 0≦t≦n
        Δ=[q, v0 vj . . . vn, s] is a prime head node satisfying 0≦s≦m
        State q=State r.
        W denotes pattern w0 w1 . . . wn and V denotes pattern v0 v1 . . . vm 
        Pattern (W, t) overlap matches (V, s) as defined in definition 3.1.
    
    


Lemma 4.25 Overlap Matching Prime Head Nodes are Equal
If Δ=[q, P, u] and Δk=[q, V, s] are prime head nodes and they overlap match, then they are equal. (Distinct edges have prime head nodes that do not overlap match.)
Proof.




0≦u≦|Δj| and 0≦s≦|Δk|. Let (I, m)=(P, u)∩(V, s) where m=min{s, u}. Suppose the same machine begins execution on tape I with tape head at m in state q. If s=u and |Δj|=|Δk|, then the proof is complete.
Otherwise, s≠u or |Δj|≠|Δk| or both. Δf has a window of execution [0, |Δj|−1] and Δk has window of execution [0, |Δk|−1]. Let the ith step be the first time that the tape head exits finite tape I. This means the machine would execute the same machine instructions with respect to Δj and Δk up to the ith step, so on the ith step, Δj and Δk must execute the same instruction. Since it exits tape I at the ith step, this would imply that either pattern P or V are exited at the ith step. This contradicts either that [0, |Δj|−1] is the window of execution for Δj or [0, |Δk|−1] is the window of execution for Δk.
Definition 4.26 Edge Node Substitution Operator Π⊕(ΔΓ)
Let ΔΓ be a prime directed edge with prime head node Δ=[q, v0 v . . . s] and tail node Γ=[r, w0 w1 . . . wn, t]. If execution node Π=[q, p0 p1 . . . pm, u] overlap matches Δ, then the edge pattern substitution operator from 3.2 induces a new execution node Π⊕(ΔΓ)=[r, (P,u)⊕[(V,s)(W,t)], k] with head k=u+t−s if u>s and head k=t if u≦s such that 0≦s, t≦n and 0≦u≦m and patterns V=v0 v1 . . . vn and W=w0 w1 . . . wn and P=p0 p1 . . . pm.
Definition 4.27 Prime Directed Edge Sequence and Link Matching
A prime directed edge sequence is defined inductively. Each element is a coordinate pair with the first element being a prime directed edge and the second element is an execution node. Each element is abstractly expressed as (ΔkΓk, Πk).
The first element of a prime directed edge sequence is (Δ1Γ1, Π1) where Π1=Γ1, and Δ1Γ1 is some prime directed edge in P. For simplicity in this definition, the indices in P are relabeled if necessary so the first element has indices equal to 1. If Π1 overlap matches some non-halting prime head node Δ2, the second element of the prime directed edge sequence is (Δ2 Γ2, Π2) where Π2=Π1⊕(Δ2Γ2). This is called a link match step.
Otherwise, Π1 overlap matches a halting node, then the prime directed edge sequence terminates. This is expressed as [(Δ1Γ1, Γ1), HALT]. In this case it is called a halting match step.
If the first k−1 steps are link match steps, then the prime directed edge sequence is denoted as [(Δ1Γ1, Π1), (Δ2Γ2, Π2), . . . , (ΔkΓk, Πk)] where Πj overlap matches prime head node Δj+1 and Πj+1=Πj⊕(Δj+1Γj+1) for each j satisfying 0≦j≦k.
Notation 4.28 Edge Sequence Notation E([p1, p2, . . . , pk], k)
To avoid subscripts of a subscript, pk and the subscript p(j) represent the same number. As defined in 4.27, P={Δ1Γ1, . . . ΔkΓk, . . . , ΔNrN} denotes the set of all prime directed edges. E([p1], 1) denotes the edge sequence [(Δp(1)Γp(1), Πp(1)] of length 1 where Πp(1)=Γp(1) and 1≦p1≦|P|. Next E([p1, p2], 2) denotes the edge sequence [(Δp(1)Γp(1), Πp(1)), (Δp(2)Γp(2), Πp(2))] of length 2 where Πp(2)=Πp(1)⊕(Δp(2)Γp(2)) and 1≦p1, p2≦|P|.
In general, E([p1, p2, . . . , pk], k) denotes the edge sequence of length k which is explicitly [(Δp(1)Γp(1), Πp(1)), (Δp(2)Γp(2), Πp(2)), . . . , (Δp(k)Γp(k), Πp(k))] where Πp(j+1)=Πp(j)⊕(Δp(j+1)Γp(j+1)) for each j satisfying 1≦j≦k−1 and 1≦p(j)≦|P|.
Definition 4.29 Edge Sequence Contains a Consecutive Repeating State Cycle
Lemma 4.19 implies that an edge sequence corresponds to a composition of prime input commands. The expression an edge sequence contains a consecutive repeating state cycle is used if the corresponding sequence of prime input commands contains a consecutive repeating state cycle.
Theorem 4.30 Any consecutive repeating state cycle of (Q, A, η) is contained in an edge sequence of (Q, A, η).
PROOF. This follows immediately from definition 4.29 and lemmas 4.15 and 4.19.
Remark 4.31 Period of an Immortal Periodic Point Contained in Edge Sequence
If E([p1, p2, . . . , pr], r) contains a consecutive repeating state cycle, then the corresponding immortal periodic point has period




  ≤
  
    
      1
      2
    
    ⁢
    
      
        ∑
        
          k
          =
          1
        
        r
      
      ⁢
      
        
          
          
            
              Δ
              
                
                  
                
                ⁢
                
                  p
                  ⁡
                  
                    (
                    k
                    )
                  
                
              
            
            ⇒
            
              Γ
              
                p
                ⁡
                
                  (
                  k
                  )
                
              
            
          
          
        
        .
      
    
  




PROOF. This follows from lemma 3.11 that a consecutive repeating state cycle induces an immortal periodic point. The length of the state cycle equals the period of the periodic point. Further, the number of input commands corresponding to the number of computational steps equals |Δp(k)Γp(k)| in directed edge Δp(k)Γp(k).
Method 4.32 Finding a Consecutive Repeating State Cycle in an Edge Sequence
Given an edge sequence whose corresponding prime input command sequence (q0, a0)(q1, a1) . . . (qN, aN) has length N
Set n=N/2 if N is even; otherwise, set n=(N+1)/2 if N is odd
for each k in {1, 2, . . . , n}












{









for each j in {0, 1, . . ., N−2k−1}



{



 if sequence (qj, aj)   (qj+1, aj+1)   . . .    (qj+k, aj+k) equals









 sequence (qj+k+1, aj+k+1)   (qj+k+2, aj+k+2)   . . .    (qj+2k+1,



 aj+2k+1)



then



{









return consecutive repeating state cycle



 (qj, aj)   (qj+1, aj+1)   . . .    (qj+k, aj+k)   . . .    (qj+k+1,



 aj+k+1)









}







 }


}









If exited outer for loop without finding a consecutive repeating state cycle
Return NO consecutive repeating state cycles were found.
Example 4.33
A newLISP Function that Finds a Consecutive Repeating Sequence












(define (find_pattern_repeats p_length seq)









(let









(









 (k 0)



 (max_k (− (length seq) (+ p_length p_length)) )



 (pattern nil)



 (repeat_pair nil)



 (no_repeats true)









)



(while (and (<= k max_k) no_repeats)









(set ′pattern (slice seq k p_length))



(if (= pattern (slice seq (+ k p_length) p_length))









(begin









(set ′repeat_pair (list pattern k))



(set ′no_repeats false)









)









)



(set ′k (+ k 1))









)









 repeat_pair







))


(define (find_repeats seq)









(let









 (









(p_length 1)



(max_p_length (/ (length seq) 2) )



(repeat_pair nil)









 )



(while (and (<= p_length max_p_length) (not repeat_pair) )









 (set ′repeat_pair (find_pattern_repeats p_length seq))



 (set ′p_length (+ p_length 1))









)



repeat_pair







))


(set ′s1 ′(3 5 7 2 3 5 7 11 5 7 ))


;; s1 does not have a consecutive repeating sequence.


(set ′s2 ′(3 5 7 2 3 5 7 11 5 7 11 2 4 6 8 ))


;; 5 7 11 5 7 11 is a consecutive repeating sequence starting at element in


list s2


(set ′s3 ′(1 2 0 2 1 0 2 0 1 2 0 2 1 0 1 2 1 0 2 1 2 0 2 1 0 1 2 0 2 1 2 0 1 2


1 0 1 2 0 1 0 1))


;; 0 1 0 1 is a consecutive repeating sequence starting at element 38 in list


s3


> (find_repeats s1)


nil


> (find_repeats s2)


( (5 7 11) 5)


> (find_repeats s3)


( (0 1) 38)









Method 4.34 Prime Directed Edge Search Method
Given Turing Machine (Q, A, η) as input, the search method works as follows.
Set P=Ø.
For each non-halting state q in Q
For each pattern a−|Q| . . . a−2 a−1 a0 a1 a2 . . . a|Q| selected from A2|Q|+1












{


 








 


With tape head located at a0, start executing machine (Q, A, η) until one 


state has been visited twice or (Q, A, η) reaches a halting state. The 


Dirichlet principle implies this will take at most |Q| computational 


steps. If it does not halt, let r be the state that is first visited twice. 


As defined in 4.1, over this window of execution, a prime directed edge 


Δ   Γ is constructed where Δ = [q, v0 v1 . . . vn, s], Γ = [r, w0 w1 . . . wn, t] 


and 0 ≦ s, t ≦ n ≦ |Q|.


Set P = P ∪ {Δ   Γ}


}









Remark 4.35 Prime Directed Edge Search Method Finds all Prime Directed Edges
Method 4.34 finds all prime directed edges of (Q, A, η) and all halting nodes.
PROOF. Let ΔΓ be a prime directed edge of (Q, A, η). Then ΔΓ has a head node A=[r, v0 v1 . . . vn, s], for some state r in Q, for some tape pattern v0 v1 . . . vn that lies in An+1, such that n≦|Q| and 0≦s≦n. In the outer loop of 4.34, when r is selected from Q and in the inner loop when the tape pattern a−|Q| . . . a−2 a−1 a0 a1 a2 . . . a|Q| is selected from A2|Q|+1 such that




  
    
      
        
          a
          0
        
        =
        
          v
          s
        
      
    
    
      
        
          a
          1
        
        =
        
          v
          
            s
            +
            1
          
        
      
    
    
      ...
    
    
      
        
          a
          k
        
        =
        
          v
          
            s
            +
            k
          
        
      
    
    
      ...
    
    
      
        
          a
          
            n
            -
            s
          
        
        =
        
          v
          n
        
      
    
  
  
    
      
        
          a
          
            -
            1
          
        
        =
        
          v
          
            s
            -
            1
          
        
      
    
    
      
        
          a
          
            -
            2
          
        
        =
        
          v
          
            s
            -
            2
          
        
      
    
    
      ...
    
    
      
        
          a
          
            -
            k
          
        
        =
        
          v
          
            s
            -
            k
          
        
      
    
    
      ...
    
    
      
        
          a
          
            -
            s
          
        
        =
        
          v
          0
        
      
    
  




then the machine execution in 4.34 will construct prime directed edge ΔΓ. When the head node is a halting node, the machine execution must halt in at most |Q| steps. Otherwise, it would visit a non-halting state twice and thus, be a non-halting head node. The rest of the argument for this halting node is the same as for the non-halting head node.

Method 4.36 Immortal Periodic Point Search Method
Given Turing Machine (Q, A, η) as input, the method works as follows.
Use method 4.34 to find all prime directed edges, P.












set k = 1.


set Φ(1) = { E([1], 1), E([2], 1), . . ., E([|P|], 1) }


while ( Φ(k) ≠ Ø )


{









set Φ(k+1) = Ø.



for each E([p1,p2, . . .,pk], k) in Φ(k)



{









for each prime directed edge Δj   Γj in P



{









if Δj   Γj link matches with Πp(k) then



{









set pk+1 = j



set Φ(k+1) = Φ(k+1) ∪ E([p1, p2, . . ., pk,pk+1], k+1)



if E([p1, p2, . . ., pk, pk+1], k+1) contains a consecutive



repeating state cycle



then return the consecutive repeating state cycle









 }









 }









}



k is incremented.







}









if (while loop exited because Φ(m)=Ø for some m) then return Ø

Remark 4.37 |Φ(k)| is finite and |Φ(k)|≦|P|k 
PROOF. |Φ(1)|=|P|. Analyzing the nested loops, in method 4.36
for each E([p1, p2, . . . , pk], k) in Φ(k)

    
    
        for each ΔjΓj in P { . . . }
    
    


For each edge sequence E([p1, p2, . . . , pk], k) chosen from Φ(k), at most |P| new edge sequences are put in Φ(k+1). Thus |Φ(k+1)|≦|P∥Φ(k)|, so |Φ(k)|≦|P|k.
Definition 4.38 Periodic Turing Machine
A Turing machine (Q, A, η) that has at least one periodic configuration, whenever it has an immortal configuration is said to be a periodic Turing machine.
Theorem 4.39 If (Q, A, η) is a periodic machine, then method 4.36 terminates in a finite number of steps with either a consecutive repeating state cycle or for some positive integer J, then Φ(J)=Ø
PROOF. If (Q, A, η) has at least one configuration (q, k, T) that has an immortal orbit, then the assumption that (Q, A, η) is a periodic machine implies the existence of a periodic point p with some finite period N. Thus, from lemma 3.10, there is a consecutive repeating state cycle that corresponds to the immortal periodic orbit of p. Since method 4.36 searches through all possible prime edge sequences of length k, a consecutive repeating state cycle will be found that is contained in a prime directed edge sequence with length at most 2N. Thus, this immortal periodic point of period N will be reached before or while computing Φ(2N).
Otherwise, (Q, A, η) does not have any configurations with an immortal orbit; in other words, for every configuration, (Q, A, η) halts in a finite number of steps.
claim: There is a positive integer J such that every edge sequence terminates while executing method 4.36. By reductio absurdum, suppose not. Then there is at least one infinite prime directed edge sequence that exists: this corresponds to an immortal orbit, which contradicts that (Q, A, η) does not have any configuration with an immortal orbit.
Periodic Point Properties
Lemma 5.1 All right head moves or all left tape head moves
If Turing Machine (Q, A, η) can execute |Q| consecutive computational steps which are all right tape head moves or all left tape head moves without halting, then the machine has an immortal periodic point with period ≦|Q|.
PROOF. Consecutive Right Tape Head Moves.
Suppose there are |Q| consecutive computational steps which are all right tape head moves. Thus, there is a sequence of |Q| commands η(qk, ak)=(qk+1, bk, R) satisfying 1≦k≦|Q| that execute these |Q| computational steps without halting. In the table below, the subscript k in each state qk indicates the state of the machine just before the kth computational step.

















State
k




k − |Q| + 1
k + |Q|







q1
a1
a2
. . .
ak
. . .
a|Q|



q2
b1
a2
. . .
ak
. . .
a|Q|



. . .









qk
b1
b2
. . .
ak
. . .
a|Q|



. . .









q|Q|
b1
b2
. . .
bk
. . .
a|Q|



q|Q|+1
b1
b2
. . .
bk
. . .
b|Q|
a|Q|+1









The Dirichlet Box principle applied to the |Q|+1 states {q1, q2 . . . q|Q|, q|Q|+1} implies that two of the states are equal; namely, qj=qk for some j<k. Thus, the point




  p
  =
  
    [
    
      
        q
        j
      
      ,
      
        
          
            
              b
              j
            
            ⁢
            
              b
              
                
                  j
                  +
                  1
                
                ⁢
                
                  
                
              
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              b
              
                k
                -
                1
              
            
          
          _
        
        ⁢
        
          
        
        ⁢
        
          
            
              〈
              
                a
                j
              
              〉
            
            ⁢
            
              a
              
                j
                +
                1
              
            
            ⁢
            
              
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              a
              
                k
                -
                1
              
            
          
          _
        
      
    
    ]
  




is an immortal periodic point with period k−j and (k−j)≦|Q|.

Consecutive Left Tape Head Moves.
Suppose there are |Q| consecutive computational steps which are all left tape head moves. Thus, there is a sequence of |Q| commands η(qk, ak)=(qk+1, bk, L) satisfying 1≦k≦|Q| that execute these |Q| computational steps without halting. In the table below, the subscript k in each state qk indicates the state of the machine just before the kth computational step.













STATE
k − |Q|
k − |Q| + 1
k






















q1

a|Q|
. . .
ak
. . .
a2
a1


q2

a|Q|
. . .
ak
. . .
a2
b1


. . .









qk

a|Q|
. . .
ak

b2
b1


. . .









q|Q|

a|Q|
. . .
bk
. . .
b2
b1


q|Q|+1
a|Q|+1
b|Q|
. . .
bk
. . .
b2
b1









The Dirichlet Box principle applied to the |Q|+1 states {q1, q2, . . . q|Q|, q|Q|+1} implies that two of the states are equal; namely, qj=qk for some j<k. Thus, the point




  p
  =
  
    [
    
      
        q
        j
      
      ,
      
        
          
            
              a
              
                k
                -
                1
              
            
            ⁢
            
              
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              〈
              
                a
                j
              
              〉
            
          
          _
        
        ⁢
        
          
        
        ⁢
        
          
            
              b
              
                
                  k
                  -
                  1
                
                ⁢
                
                  
                
              
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              b
              j
            
          
          _
        
      
    
    ]
  




is an immortal periodic point with period k−j and (k−j)≦|Q|.

Remark 5.2
Consider Turing Machine (Q, A, η). If for some q in Q, and for some a, b in A, η(q, a)=(q, b, R) or η(q, a)=(q, b, L), then (Q, A, η) has an immortal fixed point.
PROOF. If η(q, a)=(q, b, R), then p=[q, baā] is an immortal fixed point of (Q, A, η). If η(q, a)=(q, b, L), then p=[q, āa b] is an immortal fixed point of (Q, A, η).
Definition 5.3 Minimal Period
If (Q, A, η) has no immortal orbits, then it is called a halting machine. Otherwise, the minimum{C(p): p is an immortal periodic point of (Q, A, η)} is well-defined because it is the minimum of a non-empty subset of the natural numbers. This minimum is called the minimal period of (Q, A, η).
Theorem 5.4 Two State Minimal Period Theorem
If Q={q, r} has only two non-halting states and A={0, 1}, then (Q, A, η) is a halting machine or its minimal period is 1, 2 or 4.
PROOF. If (Q, A, η) is a halting machine, then the proof is completed. Otherwise; suppose (Q, A, η) has an immortal periodic point with period ≧5. Then it is shown that this implies the machine must have an immortal periodic point with period ≦4.
Consider the first 5 computational steps of the immortal periodic point p. If two consecutive steps stay in the same state, then by remark 5.2, then (Q, A, η) has an immortal periodic point with period 1. Done. Furthermore, if there are two consecutive right tape head moves or left tape head moves, during these five computational steps, then by lemma 5.1, there is an immortal periodic point with period ≦2.
Thus, W.L.O.G. (symmetry), for the remaining cases the first five computational steps look like—where the variables x1, x2, x3, x4, y1, y2, y3 represent elements of A:














STATE


MOVE
STEP







q
x1 
y1




r
x2
y1
R
1


q
x2
y2
L
2


r
x3
y2
R
3


q
x3
y3
L
4


r
x4
y3
R
5









Observation 1.
x1=x2 implies x1=x2=x3 because computational steps 1 and 3 are η(q, x1)=(r, x2, R) and η(q, x2)=(r, x3, R).
Observation 2.
y1=y2 implies that y1=y2=y3 because computational steps 2 and 4 are η(r, y1)=(q, y2, L) and η(r, y2)=(q, y3, L).
Observation 3.
Since A has 2 elements, [x1=x2 or x1=x3 or x2=x3] and [y1=y2 or y1=y3 or y2=y3].
Case 1: x2=x3 and y2=y3. Based on steps 3 and 4, point p=[q, 0x2y2 6] is an immortal periodic point with period 2.
Many of the nine cases below are reduced to previous cases.
Case 2: x1=x2 and y2=y3. The first observation reduces case 2 to case 1.
Case 3: x1=x3 and y2=y3. By replacing all occurrences of x3 by x1 and all occurrences of y3 by y2, then the previous table becomes:














STATE


MOVE
STEP







q
x1
y1




r
x2
y1
R
1


q
x2
y2
L
2


r
x1
y2
R
3


q
x1
y2
L
4


r
x2
y2
R
5


q
x2
y2
L
6









After the substitution, from step 4, then η(r, y2)=(q, y2, L). This implies step 6 in the table.
Looking at steps 2 and 6, point p=[q, 0x2y2 0] is an immortal periodic point with period 2 or 4.
Case 4: x1=x3 and y1=y3. Substituting x1 for x3 and y1 for y3 in step 4 of the original table, then the point p=[q, 0x1y1 0] is an immortal periodic point with period 2 or 4.
Case 5: x1=x2 and y1=y3. This reduces to case 4 from the first observation.
Case 6: x2=x3 and y1=y3. Substituting x2 for x3 and y1 for y3 in the original table and observing that from step 3 that η(q, x2)=(q, x2, R). This implies that x4=x2














STATE


MOVE
STEP







q
x1
y1




r
x2
y1
R
1


q
x2
y2
L
2


r
x2
y2
R
3


q
x2
y1
L
4


r
x2
y1
R
5









Then observe that after step 1 and step 5, the points are identical. Thus, the point p=[r, 0x2y1 0] is immortal with period equal to 2 or 4.
Case 7: x1=x2 and y1=y2.
This reduces to case 2 from the second observation.
Case 8: x1=x3 and y1=y2. This reduces to case 4 from the second observation.
Case 9: x2=x3 and y1=y2. This reduces to case 6 from the second observation.
Finally, it is shown that any machine having an immortal periodic point with period 3 must have an immortal periodic point with period 1 or 2. Suppose the machine has an immortal period 3 point. During the three computational steps, the claim is that there has to be two consecutive steps that are in the same state. For example, the state sequence q, r, q, r would contradict that it is a period 3 orbit because at step 0 it is in state q and after step 3 it is in state r; similarly, the state sequence r, q, r, q would contradict that is a period 3 orbit. Thus, there must be two consecutive steps that are in the same state, which implies it is an immortal fixed point. Thus, the machine can not have a minimal period of 3.
Immortal Orbit and Recurrent Points
In this section, recurrent points (configurations) are defined and the Immortal Orbit theorem is shown, which generalizes the behavior in the two previous examples. In particular, if machine (Q, A, η) has an immortal configuration (q, k, T), then the corresponding orbit of the point p=φ(q, k, T) with respect to the corresponding affine functions has a recurrent point and at least one recurrent point z is a fixed point of a composition sequence of these affine functions iterated according to the correspondence in Theorem 2.22
Definition 6.1 Recurrent Points
Let X be a metric space, S: N→N a function index sequence, and a family of functions ƒk: X→X, where kεN. The orbit of point pεX is {p, ƒS(1)(p), ƒS(2)ƒS(1)(p), . . . , ƒS(m)ƒS(m−1) . . . ƒS(2) ƒS(1)(p), . . . }. The ω-limit set, ω(p, ƒk), is the set of cluster points of the orbit of p i.e.




  
    ω
    ⁡
    
      (
      
        p
        ,
        
          f
          k
        
      
      )
    
  
  =
  
    
      ⋂
      
        n
        ∈
        N
      
    
    ⁢
    
      
        
          {
          
            
              
                f
                
                  S
                  ⁡
                  
                    (
                    k
                    )
                  
                
              
              ∘
              
                f
                
                  S
                  ⁡
                  
                    (
                    
                      k
                      -
                      1
                    
                    )
                  
                
              
              ∘
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ∘
              
                
                  f
                  1
                
                ⁡
                
                  (
                  p
                  )
                
              
            
            :
            
              k
              >
              n
            
          
          }
        
        _
      
      .
    
  




Any point zεX that lies in ω(p, ƒk) is called a recurrent point. The closure of the set of recurrent points of ƒk is denoted R(ƒk) and is called the recurrent set of ƒk.

An aperiodic Turing machine has at least one immortal configuration, but has no periodic immortal configurations. This first example is an aperiodic Turing machine.
Example 6.2
Aperiodic Turing Machine Execution and Affine Orbit Correspondence
Consider the Turing machine with state set Q={a, b, c, d, e, f}, halting state h and alphabet A={0, 1, 2, 3}. The Turing program η is shown below.



  
    
      η
      ⁡
      
        (
        
          a
          ,
          0
        
        )
      
    
    =
    
      (
      
        d
        ,
        1
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          a
          ,
          1
        
        )
      
    
    =
    
      (
      
        f
        ,
        1
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          a
          ,
          2
        
        )
      
    
    =
    
      (
      
        f
        ,
        2
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          a
          ,
          3
        
        )
      
    
    =
    
      (
      
        f
        ,
        3
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          b
          ,
          0
        
        )
      
    
    =
    
      (
      
        c
        ,
        1
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          b
          ,
          1
        
        )
      
    
    =
    
      (
      
        e
        ,
        1
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          b
          ,
          2
        
        )
      
    
    =
    
      (
      
        e
        ,
        2
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          b
          ,
          3
        
        )
      
    
    =
    
      (
      
        e
        ,
        3
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          c
          ,
          0
        
        )
      
    
    =
    
      (
      
        a
        ,
        2
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          c
          ,
          1
        
        )
      
    
    =
    
      (
      
        f
        ,
        1
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          c
          ,
          2
        
        )
      
    
    =
    
      (
      
        f
        ,
        2
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          c
          ,
          3
        
        )
      
    
    =
    
      (
      
        f
        ,
        3
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          d
          ,
          0
        
        )
      
    
    =
    
      (
      
        b
        ,
        2
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          d
          ,
          1
        
        )
      
    
    =
    
      (
      
        e
        ,
        1
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          d
          ,
          2
        
        )
      
    
    =
    
      (
      
        e
        ,
        2
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          d
          ,
          3
        
        )
      
    
    =
    
      (
      
        e
        ,
        3
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          e
          ,
          0
        
        )
      
    
    =
    
      (
      
        a
        ,
        3
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          e
          ,
          1
        
        )
      
    
    =
    
      (
      
        a
        ,
        0
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          e
          ,
          3
        
        )
      
    
    =
    
      (
      
        d
        ,
        0
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          e
          ,
          3
        
        )
      
    
    =
    
      (
      
        f
        ,
        0
        ,
        R
      
      )
    
  




  
    
      n
      ⁡
      
        (
        
          f
          ,
          0
        
        )
      
    
    =
    
      (
      
        b
        ,
        3
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          f
          ,
          1
        
        )
      
    
    =
    
      (
      
        b
        ,
        0
        ,
        R
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          f
          ,
          2
        
        )
      
    
    =
    
      (
      
        c
        ,
        0
        ,
        L
      
      )
    
  




  
    
      η
      ⁡
      
        (
        
          f
          ,
          3
        
        )
      
    
    =
    
      (
      
        e
        ,
        0
        ,
        L
      
      )
    
  



Base B=|Q|A|+1=11. The value function v: A∪Q∪{h}→N is defined explicitly as v(h)=0. v(0)=1. v(1)=2. v(2)=3. v(3)=4. v(a)=5. v(b)=6. v(c)=7. v(d)=8. v(e)=9. and v(f)=10. Before program execution starts, we assume the machine is in state b. See FIGS. 28 and 29. The tape head is at tape square 2. T(1)=2, T(0)=1 and all other tape squares contain 0 i.e. the initial machine configuration is [b, 00 0]. The first computational step is η(b, 0)=(c, 1, −1) which is equivalent to applying the affine map




  
    
      f
      1
    
    ⁡
    
      (
      
        x
        ,
        y
      
      )
    
  
  =
  
    
      (
      
        
          
            
              1
              11
            
            ⁢
            x
          
          +
          34
        
        ,
        
          
            11
            ⁢
            y
          
          -
          682
        
      
      )
    
    ⁢
    
      
    
    ⁢
    to
    ⁢
    
      
    
    ⁢
    the
    ⁢
    
      
    
    ⁢
    point
    ⁢
    
      
    
    ⁢
    
      
        (
        
          
            12
            ⁢
            
              1
              10
            
          
          ,
          
            69
            ⁢
            
              21
              110
            
          
        
        )
      
      .
    
  




The calculation of the x-coordinate is




  
    
      11
      ⁢
      
        v
        ⁡
        
          (
          0
          )
        
      
    
    +
    
      v
      ⁡
      
        (
        0
        )
      
    
    +
    
      
        1
        11
      
      
        1
        -
        
          1
          11
        
      
    
  
  =
  
    12
    ⁢
    
      
        1
        10
      
      .
    
  




The y-coordinate is





  
    
      11
      ⁢
      
        v
        ⁡
        
          (
          b
          )
        
      
    
    +
    
      v
      ⁡
      
        (
        2
        )
      
    
    +
    
      
        1
        11
      
      ⁢
      
        v
        ⁡
        
          (
          1
          )
        
      
    
    +
    
      
        1
        
          11
          2
        
      
      
        1
        -
        
          1
          11
        
      
    
  
  =
  
    69
    ⁢
    
      
        21
        110
      
      .
    
  




Observe that the machine configuration [b, 00 0] is a recurrent point of this orbit starting at point [b, 0120 0]. Furthermore,





  
    φ
    ⁡
    
      [
      
        b
        ,
        
          
            0
            _
          
          ⁢
          
            0
            _
          
          ⁢
          
            0
            _
          
        
      
      ]
    
  
  ⁢
  
    
  
  =
  
    
  
  ⁢
  
    
      (
      
        
          12
          ⁢
          
            1
            10
          
        
        ,
        
          67
          ⁢
          
            1
            10
          
        
      
      )
    
    .
  




Observe that





  
    
      f
      3
    
    ⁢
    
      f
      2
    
    ⁢
    
      
        f
        1
      
      ⁡
      
        (
        
          x
          ,
          y
        
        )
      
    
  
  =
  
    (
    
      
        
          11
          ⁢
          x
        
        -
        121
      
      ,
      
        
          
            1
            11
          
          ⁢
          y
        
        +
        61
      
    
    )
  




has fixed point





  (
  
    
      12
      ⁢
      
        1
        10
      
    
    ,
    
      67
      ⁢
      
        1
        10
      
    
  
  )




which corresponds to recurrent point [b, 00 0]. Also, observe that





  
    
      f
      12
    
    ⁢
    
      f
      11
    
    ⁢
    
      
    
    ⁢
    ...
    ⁢
    
      
    
    ⁢
    
      f
      5
    
    ⁢
    
      
        f
        4
      
      ⁡
      
        (
        
          x
          ,
          y
        
        )
      
    
  
  =
  
    
      (
      
        
          
            11
            ⁢
            x
          
          -
          121
        
        ,
        
          
            
              1
              11
            
            ⁢
            y
          
          +
          61
        
      
      )
    
    .
  




In other words, this recurrent point of the immortal orbit is a fixed point of a finite composition sequence of the corresponding affine maps.

A Turing machine that has at least one periodic configuration, whenever it has an immortal configuration is called a periodic Turing machine.
Example 6.3
Q={q0, q1 q2} A={#, a, b}
η(q0, #)=(q1, a, R). η(q0, a)=(q0, a, L). η(q0, b)=(q0, b, L).
η(q1, #)=(q0, b, L). η(q1, a)=(q1, a, R). η(q1, b)=(q1, b, R).
η(q2, #)=(h, #, R). η(q2, a)=(h, a, R). η(q2, b)=(h, b, R).
The initial tape contents are all #'s. Formally, T(k)=# for every integer k. Base B=|Q|+|A|+1=7. The value function ν: A∪Q∪{h}→N is explicitly ν(h)=0 ν(#)=1 ν(a)=2 ν(b)=3 ν(q0)=4 ν(q1)=5 νν(q2)=6.
In regard to the affine orbit and Turing Machine execution correspondence see FIGS. 30, 31 and 32. The affine functions ƒj and unit square domains Wj, the current Turing Machine state, tape head and tape are shown after each execution step. The location of the tape head is indicated by underlining the tape symbol and placing the state of the machine directly underneath this tape square.
The point




  u
  =
  
    
      (
      
        
          14
          +
          3
          +
          
            
              3
              7
            
            
              1
              -
              
                1
                7
              
            
          
        
        ,
        
          35
          +
          2
          +
          
            
              2
              7
            
            
              1
              -
              
                1
                7
              
            
          
        
      
      )
    
    =
    
      (
      
        
          17
          ⁢
          
            1
            2
          
        
        ,
        
          37
          ⁢
          
            1
            3
          
        
      
      )
    
  




is a recurrent point that corresponds to the machine being in state q1 and the tape head location is at square 1 and the tape contents are T(k)=a whenever k≦1 and T(k)=b whenever k>1.

The point




  v
  =
  
    
      (
      
        
          
            2
            ·
            7
          
          +
          2
          +
          
            
              2
              7
            
            
              1
              -
              
                1
                7
              
            
          
        
        ,
        
          
            5
            ·
            7
          
          +
          2
          +
          
            
              2
              7
            
            
              1
              -
              
                1
                7
              
            
          
        
      
      )
    
    =
    
      (
      
        
          16
          ⁢
          
            1
            3
          
        
        ,
        
          37
          ⁢
          
            1
            3
          
        
      
      )
    
  




is a recurrent point of the immortal orbit that corresponds to the machine being in state q1 and the tape head location can be at any square j and the tape contents are T(k)=a for every k on the tape. Observe that v is a fixed point of





  
    
      f
      14
    
    ⁡
    
      (
      
        x
        ,
        y
      
      )
    
  
  =
  
    (
    
      
        
          7
          ⁢
          
            
          
          ⁢
          x
        
        -
        98
      
      ,
      
        
          
            1
            7
          
          ⁢
          y
        
        +
        32
      
    
    )
  




lying in the interior of the unit square W14=[(16, 37), (17, 37), (17, 38), (16, 38)].

Set




  
    v
    0
  
  =
  
    (
    
      
        16
        ⁢
        
          145
          294
        
      
      ,
      
        37
        ⁢
        
          1
          6
        
      
    
    )
  




which is when the tape head is at 0; the machine is in state q1; and T(0−1)=T(0)=T(0+1)=a. Then ν0 is in this immortal orbit.













Tape Coordinate


















−1
0
1
2
3
4
5
6
7
8





Tape
a
a
a
b
b
#
#
#
#
#


Contents












State

q1









Set ν1=to the first time the point in the immortal orbit has its tape head at 4; and the machine is in state q0; and T(−1−2)=T(−1−1)=T(−1)=T(−1+1)=T(−1+2)=a.












Tape Coordinate





















−4
−3
−2
−1
0
1
2
3
4
5
6
7
8





Tape
#
a
a
a
a
a
b
b
b
b
#
#
#


Contents















State



q1









By induction, for every k>1, set νk=to the first time the point in the immortal orbit has its tape head at −k; the machine is in state q0; and T(−k+j)=a for every j such that |j|≦k+1. This implies that




  
    
      lim
      
        n
        →
        ∞
      
    
    ⁢
    
      v
      n
    
  
  =
  
    v
    .
  




The point




  w
  =
  
    
      (
      
        
          
            21
            ·
            7
          
          
            7
            -
            1
          
        
        ,
        
          
            -
            189
          
          
            1
            -
            7
          
        
      
      )
    
    =
    
      (
      
        
          24
          ⁢
          
            1
            2
          
        
        ,
        
          31
          ⁢
          
            1
            2
          
        
      
      )
    
  




is a recurrent point of the immortal orbit that corresponds to the machine being in state q0 and the tape head location can be at any square j and the tape contents are T(k)=b for every k on the tape. Observe that w is a fixed point of η8(x,y)=( 1/7x+21, 7y−189) lying in the interior of the unit square W8=[(24, 31), (25, 31), (25, 32), (24, 32)]. Also, observe that if





  
    w
    3
  
  =
  
    (
    
      
        24
        ⁢
        
          1
          6
        
      
      ,
      
        31
        ⁢
        
          685
          2085
        
      
    
    )
  




which is when the tape head is at 3; and the machine is in state q0; and T(3−1)=T(3)=T(3+1)=b, then w3 is in this immortal orbit.













Tape Coordinate


















−1
0
1
2
3
4
5
6
7
8





Tape
a
a
a
b
b
b
#
#
#
#


Contents












State




q0









Set w4 equal to the first time the point in the immortal orbit has its tape head at 4; and the machine is in state q0; and T(4−2)=T(4−1)=T(4)=T(4+1)=T(4+2)=b.












Tape Coordinate





















−4
−3
−2
−1
0
1
2
3
4
5
6
1
8





Tape
#
a
a
a
a
a
b
b
b
b
b
#
#


Contents















State








q0









By induction, for every k>4, set wk equal to the first time the point in the immortal orbit has its tape head at k; and the machine is in state q0; and T(k+j)=b for every j such that |j|≦k−2. Observe that




  
    
      lim
      
        n
        →
        ∞
      
    
    ⁢
    
      w
      n
    
  
  =
  
    w
    .
  




The next theorem states what was already illustrated in the previous examples.
Theorem 6.4 an Immortal Orbit has Recurrent Points.
PROOF. Let ε>0. Let ƒ1, ƒ2, . . . , ƒ1 denote the I affine functions with corresponding unit square domains W1, W2, W3, . . . , WI. Let p be an immortal point. Then its orbit




  
    {
    
      p
      ,
      
        
          f
          
            S
            ⁡
            
              (
              1
              )
            
          
        
        ⁡
        
          (
          p
          )
        
      
      ,
      
        
          f
          
            S
            ⁡
            
              (
              2
              )
            
          
        
        ⁢
        
          
            f
            
              S
              ⁡
              
                (
                1
                )
              
            
          
          ⁡
          
            (
            p
            )
          
        
      
      ,
      ...
      ⁢
      
        
      
      ,
      
        
          f
          
            S
            ⁡
            
              (
              m
              )
            
          
        
        ⁢
        
          f
          
            S
            ⁡
            
              (
              
                m
                -
                1
              
              )
            
          
        
        ⁢
        
          
        
        ⁢
        ...
        ⁢
        
          
        
        ⁢
        
          f
          
            S
            ⁡
            
              (
              2
              )
            
          
        
        ⁢
        
          
            f
            
              S
              ⁡
              
                (
                1
                )
              
            
          
          ⁡
          
            (
            p
            )
          
        
      
      ,
      ...
    
    ⁢
    
      
    
    }
  
  ⊆
  
    
      
        ⋃
        
          k
          =
          1
        
      
      I
    
    ⁢
    
      
        W
        k
      
      .
    
  




The area of





  
    
      ⋃
      
        k
        =
        1
      
    
    I
  
  ⁢
  
    W
    k
  




equals I. There exists a natural number N such that





  
    1
    N
  
  <
  
    
      ɛ
      
        2
      
    
    .
  




Consider the first I(N2+1) points of this orbit. Then at least N2+1 points of the orbit must lie in at least one of these unit squares Wk. This implies that there are two points from the orbit in unit square Wk with the distance between them less than or equal to





  
    1
    N
  
  .




By choosing each Nk such that





  
    N
    k
  
  <
  
    
      1
      2
    
    ⁢
    
      N
      
        k
        -
        1
      
    
  




and using induction, create a subsequence {p1, p2, . . . } of the immortal orbit of p such that pk→z. Then z is a recurrent point.

Definition 6.5 Cluster Point
Let {pn}n=1∞ be a sequence of points and d a metric. The point q is a cluster point of {pn}n=1∞ if for any ε>0 and for any N, there exists m≧N such that d(q, pm)<ε.
Definition 6.6 Immortal Points
Let




  
    U
    ⁡
    
      (
      
        Q
        ,
        A
        ,
        η
      
      )
    
  
  =
  
    {
    
      p
      ∈
      
        
          
            ⋃
            
              k
              =
              1
            
          
          I
        
        ⁢
        
          
            W
            k
          
          :
        
      
    
  




p has an immortal orbit with respect to machine (Q, A, η)}U is called the set of immortal points with respect to Turing machine (Q, A, η).

Theorem 6.7 Immortal Points are a Closed Set
Suppose




  
    
      lim
      
        n
        →
        ∞
      
    
    ⁢
    
      p
      n
    
  
  =
  p




and for each n that pn lies in U(Q, A, η). Then p is an immortal point.

PROOF. Since




  
    
      lim
      
        n
        →
        ∞
      
    
    ⁢
    
      p
      n
    
  
  =
  p




a subsequence qn of pn may be constructed with the property that





  
    d
    ⁡
    
      (
      
        
          q
          n
        
        ,
        p
      
      )
    
  
  <
  
    1
    
      B
      n
    
  




where base B=|Q|+|A|+1. This means the corresponding tape of p and the corresponding tape of qn are the same for the first n symbols on the tape in both directions.













p


Tape Contents



















. . .
bn+1
bn
. . .
b1
a0
a1
. . .
an
an+1
. . .





State with tape





w







head at a0










qn


Tape Contents



















. . .
dn+1
bn
. . .
b1
a0
a1
. . .
an
cn+1
. . .





State with tape





w







head at a0









By reductio absurdum, suppose p is not an immortal point. Then execution of (Q, A, η) on p halts at the Nth execution step for some natural number N. Since each computational step of (Q, A, η) moves either one tape square to the left or to the right, this means that execution of (Q, A, η) on p must halt on some tape symbol ak or bk such that k≦N. Assuming execution begins at tape square 0 or renumbering if necessary: this means that (Q, A, η) starting at point p must halt before moving to the right of tape square N or to the left of tape square—N. Consider point qN+2. By assumption, qN+2 is immortal but the first N+2 execution steps of (Q, A, η) on qN+2 and p must be the same because their tape symbols agree in both directions for at least the first N+2 tape squares. This is a contradiction: p halts on execution step N and qN+2 does not halt on step N. Thus, p must be an immortal point.
Lemma 6.8 Every point in an immortal orbit and all cluster points lie in the interior of




  
    ⋃
    
      k
      =
      1
    
    I
  
  ⁢
  
    
      W
      k
    
    .
  




Each point is a distance at least





  1
  
    B
    -
    1
  




from the boundary of every Wk.

PROOF. Consider a non-halting Turing machine execution. After every execution step, the state in the machine configuration is not in a halting state, h and the tape's range is in A. Further, recall that ν(h)=0, ν(a1)=1, ν(a|A|)=|A| and ν(q|Q|)=B−1. If the tape contents of every tape square is a1, this corresponds to x and y coordinates whose fractional parts are




  
    
      1
      B
    
    
      1
      -
      
        1
        B
      
    
  
  =
  
    
      1
      
        B
        -
        1
      
    
    .
  




If the tape contents of every tape square is a|A|, which is the tape symbol with the largest value with respect to ν, then this corresponds to x and y coordinates whose fractional parts are





  
    
      
        
        A
        
      
      B
    
    
      1
      -
      
        1
        B
      
    
  
  =
  
    
      
        
        A
        
      
      
        B
        -
        1
      
    
    .
  




Thus, the point p in the immortal orbit corresponding to each configuration has the property that




  
    
      
        
        
          
            x
            ⁡
            
              (
              p
              )
            
          
          -
          
            ⌊
            
              x
              ⁡
              
                (
                p
                )
              
            
            ⌋
          
        
        
      
      ≥
      
        1
        
          B
          -
          1
        
      
    
    ,
    
      
        
        
          
            y
            ⁡
            
              (
              p
              )
            
          
          -
          
            ⌊
            
              y
              ⁡
              
                (
                p
                )
              
            
            ⌋
          
        
        
      
      ≥
      
        1
        
          B
          -
          1
        
      
    
  




  
    
      
        
        
          
            ⌈
            
              x
              ⁡
              
                (
                p
                )
              
            
            ⌉
          
          -
          
            x
            ⁡
            
              (
              p
              )
            
          
        
        
      
      ≥
      
        
          
            (
            
              B
              -
              1
            
            )
          
          
            B
            -
            1
          
        
        -
        
          
            
            A
            
          
          
            B
            -
            1
          
        
      
    
    =
    
      
        
        Q
        
      
      
        B
        -
        1
      
    
  




  and




  
    
      
        
        
          
            ⌈
            
              y
              ⁡
              
                (
                p
                )
              
            
            ⌉
          
          -
          
            y
            ⁡
            
              (
              p
              )
            
          
        
        
      
      ≥
      
        
          
            (
            
              B
              -
              1
            
            )
          
          
            B
            -
            1
          
        
        -
        
          
            
            A
            
          
          
            B
            -
            1
          
        
      
    
    =
    
      
        
          
          Q
          
        
        
          B
          -
          1
        
      
      .
    
  



Thus, any cluster point of the immortal orbit must be at least





  1
  
    B
    -
    1
  




from the boundary of each Wk.

Before the main result is reached, it is helpful to do some elementary counting of finite tape patterns (strings) based on the finite alphabet A and the finite state set Q regardless of the particular Turing machine program η.
Example 6.9
The Alphabet A={1, 2, 3}
s1s2=12 is a particular 2-string where s1=1 and s2=2




The 2-string 12 occurs four times on the above tape. The 2-string 12 is non-overlapping. The 3-string s1s2 s3=123 occurs two times on the above tape.
Definition 6.10 Alphabet Strings
Suppose alphabet A={a1, a2, a3 . . . , an}. A k-string is a string of k symbols denoted as s1s2 s3 . . . sk where each sj lies in A.
Definition 6.11 Overlapping and Disjoint Tape Strings
Let Tk denote the alphabet symbol on the kth square of the Turing tape. Then Tk Tk+1 . . . Tn, where k is an n−k+1 string of alphabet symbols. The two strings Tj Tj+1 . . . Tm and Tk Tk+1 . . . Tn are disjoint if m<k OR n<j. Otherwise, they are called overlapping strings.
Furthermore, overlapping strings are distinct if j≠k OR m≠n.
Definition 6.12 Identical Tape Strings
The two tape strings Tj Tj+1 . . . Tm and Tk Tk+1 . . . Tn are identical if they are the same length (i.e. n−k=m−j) and Tk+i=Tj+i for each i satisfying 1≦i≦n−k.
Definition 6.13 Identical Program Execution up to Bn 
Two Turing machines M1(Q1, A1, ηi) and M2(Q2, A2, η2) have identical program execution up to Bn if there is an isomorphism Ψ: M1→M2 such that the following conditions hold.

    
    
        (1) Both φ: Q1→Q2 and γ: A1→A2 are bijective functions.
        (2) Ψ(η1)=η2 such that Ψη1(q, a)=η2(φ(q), γ(a))
        (3) Machine M1 has tape head location j and machine M2 has tape head location k.
        (4) Ψ(Tj+m)=Γk+m for every m such that −n≦m≦n where T is the tape for M1 and Γ is the tape for M2.
        (5) M1 program execution is in state r and M2 program execution is in state q.
        (6) φ(r)=q.
    
    


The same machine can be identical to itself up to Bn at two different steps in its program execution.
Example 6.14
Overlapping 3-Strings
Consider A={0, 1} and string 000 001 010 011 100 101 110 111 a1a2a3. The substring at the end, a1a2a3, repeats one of the previous 3-strings. In a string of length |A|3+3 at least one 3-string is repeated. For example, in the following string of length 11 where a1a2a3 . . . a11=0101 0011 101, observe that a2a3a4=a9a10a11=101.
Example 6.15
Distinct Overlapping 2-Strings
In any string of length |A|2+2, two distinct overlapping 2-strings are repeated.




  
    
      
        A
        =
        
          {
          
            0
            ,
            1
          
          }
        
      
    
    
      0000
    
  
  
    
      
        
      
    
    
      0001
    
  
  
    
      
        
      
    
    
      00101
    
  
  
    
      
        
      
    
    
      00100
    
  
  
    
      
        
      
    
    
      001101
    
  
  
    
      
        
      
    
    
      01000
    
  
  
    
      
        
      
    
    
      01001
    
  
  
    
      
        
      
    
    
      0101
    
  
  
    
      
        
      
    
    
      011000
    
  
  
    
      
        
      
    
    
      011001
    
  
  
    
      
        
      
    
    
      0111
    
  
  
    
      
        
      
    
    
      ...
    
  




Duality of 0 and 1 for the remaining eight have corresponding repeats as the first eight.

Remark 6.16 Distinct overlapping n-strings that are substrings of any string of length L=|A|n+n implies that at least two substrings are identical.
PROOF. Let a1 a2 a3 . . . az, be any alphabet string constructed from A. Define the set of n-strings S={aj+1 aj+2 . . . aj+n: 0≦j≦|A|n}. All elements of S are substrings of a1a2a3 . . . aL. By the definition of S, there are |A|n+1 distinct overlapping substrings of a1a2a3 . . . aL but the maximum number of non-identical n-strings constructed from A is |A|n. Thus, at least two n-strings must be identical.
Lemma 6.17 Distinct overlapping n-strings that are substrings of any string of length L=|A|n+n implies that at least m+1 substrings are identical.
PROOF. Define S={aj+1 aj+2 . . . aj+n: 0≦j≦m|A|n}. The rest of the proof is similar to the proof in 6.16.
Corollary 6.18 Any Turing tape string of length L=|Q∥A|n+n has at least one n-string that occurs |Q|+1 times. In other words, the tape string has |Q|+1 identical, distinct, overlapping substrings.
PROOF. This follows immediately from lemma 6.17 and definitions 6.10, 6.11 and 6.12.
Definition 6.19 Composition Sequence of Affine Maps
Consider Turing machine (Q, A, η). Suppose that over the next n computational steps, the sequence of machine configurations is (q0, k0, T0), (q1, kn, T1), . . . , (qn, kn, Tn). Let p=φ(q0, k0, T0).
According to Theorem 2.22, consider corresponding orbit, [p, ƒS(1)(p), ƒS(2)∘ƒS(1)(p), . . . , ƒS(n)∘ƒS(n−1) . . . ƒS(2) ƒS(1))(p), . . . ]. Then for each k≧1 and for every m≧k, the affine map ƒS(m)∘ƒS(m−1)∘ . . . ∘ƒS(k) is called a composition sequence of affine functions or a composition sequence.
Theorem 6.20 If machine (Q, A, η) has an immortal configuration (q, k, T), then Theorem 6.4 implies the orbit of the point p=φ(q, k, T) with respect to the corresponding affine functions has at least one recurrent point. Moreover, there is at least one recurrent point z of this immortal orbit that is a fixed point of a composition sequence of the affine functions iterated according to the correspondence in 2.22
PROOF. Let ƒ1, ƒ2, . . . ƒI denote I affine functions with corresponding unit square domains W1, W2, W3, . . . , WI induced by a Turing machine (Q, A, η) where base B=|Q|+|A|+1. Let p=(x(q, k, T), y(q, k, T)) for some immortal configuration (q, k, T) with respect to (Q, A, η). Then the orbit of p, [p, ƒS(1)(p), ƒS(2)ƒS(1)(p), . . . , ƒS(m)ƒS(m−1) . . . ƒS(2) ƒS(1)p, . . . ], is an immortal orbit.
For convenience of notation, set p0=p, p1=ƒS(1)(p), p2=ƒS(2)ƒS(1)(p), . . . , pm=ƒS(m)ƒS(m−1) . . . ƒS(2)ƒS(1)(p), . . . Define the set Ω={pk: k≧0} i.e. the immortal orbit considered as a set instead of a sequence. If the immortal orbit [p0, P1, pz, . . . , pm, . . . ] is periodic, then we are done as we have an immortal periodic point. Otherwise, set Ω contains an infinite number of distinct points. From 6.4 using induction, we can construct a subsequence {sk} of the immortal orbit such that




  
    d
    ⁡
    
      (
      
        
          s
          k
        
        ,
        
          s
          
            k
            +
            1
          
        
      
      )
    
  
  ≤
  
    1
    
      k
      2
    
  




for every k. It follows that





  
    
      lim
      
        n
        ->
        ∞
      
    
    ⁢
    
      s
      n
    
  
  =
  
    z
    .
  




Thus, z is a cluster point of subsequence {sk} which is a subset of Ω. And theorem 6.7 implies that z is an immortal point.

By choosing appropriate elements from the subsequence {sk} that converges to z, there exists a subsequence of the immortal orbit [p0, p1, p2, . . . , pm, . . . ] with the following properties:
A.




  
    
      lim
      
        n
        ->
        ∞
      
    
    ⁢
    
      z
      n
    
  
  =
  z




B. For all n,




  
    z
    n
  
  ∈
  
    interior
    ⁢
    
      ⋃
      
        k
        =
        1
      
      I
    
    ⁢
    
      
        W
        k
      
      ⁢
      
        
      
      ⁢
      and
      ⁢
      
        
      
      ⁢
      z
    
  
  ∈
  
    interior
    ⁢
    
      
    
    ⁢
    
      ⋃
      
        k
        =
        1
      
      I
    
    ⁢
    
      
        W
        k
      
      .
    
  




C.




  
    d
    ⁡
    
      (
      
        
          z
          n
        
        ,
        z
      
      )
    
  
  <
  
    1
    
      B
      n
    
  




D. zn+1=rn(zn) where rn is the affine function that is the composition of the finite sequence of functions mapping zn to zn+1 in the immortal orbit.
Consider the sequence of squares [an, bn, cn, dn] with center zn and sides with length




  4
  
    B
    
      n
      -
      1
    
  




for n>1. See FIG. 30. From lemma 6.8, z is in the interior of Wj for some j. Set δ=infimum{d(p, z): pε∂W}. Since z is in the interior, then δ>0. Thus, there is a natural number N such that





  
    
      4
      ⁢
      
        2
      
    
    
      B
      
        N
        -
        1
      
    
  
  <
  
    
      δ
      2
    
    .
  




Thus, for n≧N this geometrically means that if z is in the square [an, bn, cn, dn] then this whole square is a subset of Wj. Also, observe that




  
    
      
        
          
            d
            ⁡
            
              (
              
                
                  z
                  n
                
                ,
                
                  z
                  
                    n
                    +
                    1
                  
                
              
              )
            
          
          ≤
          
          ⁢
          
            
              d
              ⁡
              
                (
                
                  
                    z
                    n
                  
                  ,
                  z
                
                )
              
            
            +
            
              d
              ⁡
              
                (
                
                  z
                  ,
                  
                    z
                    
                      n
                      +
                      1
                    
                  
                
                )
              
            
          
        
      
    
    
      
        
          <
          
          ⁢
          
            
              1
              
                B
                n
              
            
            +
            
              1
              
                B
                
                  n
                  +
                  1
                
              
            
          
        
      
    
    
      
        
          <
          
          ⁢
          
            2
            
              B
              n
            
          
        
      
    
    
      
        
          ≤
          
          ⁢
          
            
              2
              N
            
            ⁢
            
              1
              
                B
                
                  n
                  -
                  1
                
              
            
          
        
      
    
    
      
        
          ≤
          
          ⁢
          
            1
            
              B
              
                n
                -
                1
              
            
          
        
      
    
  




  because




  
    B
    ≥
    2.
  



See FIG. 31. The previous inequalities imply that zn+1 and z are in the interior of square [an, bn, cn, dn] since zn is at the center. Thus, square [an, bn, cn, dn] is a subset of Wj for n≧N.
Covering Condition.
CLAIM: If for some n≧N, the linear part of at least one rn is of the form




  
    (
    
      
        
          
            B
            m
          
        
        
          0
        
      
      
        
          0
        
        
          
            1
            
              B
              m
            
          
        
      
    
    )
  
  ⁢
  
    
  
  ⁢
  or
  ⁢
  
    
  
  ⁢
  
    (
    
      
        
          
            1
            
              B
              m
            
          
        
        
          0
        
      
      
        
          0
        
        
          
            B
            m
          
        
      
    
    )
  




for some m≧1, then rn([an, bn, cn, dn]) horizontally or vertically covers the square [an, bn, cn, dn].

PROOF: In the case that rn is of the form




  
    (
    
      
        
          
            1
            
              B
              m
            
          
        
        
          0
        
      
      
        
          0
        
        
          
            B
            m
          
        
      
    
    )
  
  ,




recall that y(p) denotes the y coordinate of point p and x(p) denotes the x coordinate of point p.

Condition A. in Definition 1.8
Thus,




  
    
      y
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              c
              n
            
            )
          
        
        )
      
    
    -
    
      y
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              a
              n
            
            )
          
        
        )
      
    
  
  =
  
    
      
        B
        m
      
      ⁢
      
        4
        
          B
          
            n
            -
            1
          
        
      
    
    ≥
    
      
        4
        ⁢
        B
      
      
        B
        
          n
          -
          1
        
      
    
  




where B≧2 and m≧1.

Observe that




  
    y
    ⁡
    
      (
      
        z
        
          n
          +
          1
        
      
      )
    
  
  =
  
    
      1
      2
    
    ⁢
    
      
        {
        
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    a
                    n
                  
                  )
                
              
              )
            
          
          +
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    c
                    n
                  
                  )
                
              
              )
            
          
        
        }
      
      .
    
  




Thus,




  
    
      y
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              c
              n
            
            )
          
        
        )
      
    
    -
    
      y
      ⁡
      
        (
        
          z
          
            n
            +
            1
          
        
        )
      
    
  
  =
  
    
      
        1
        2
      
      ⁢
      
        {
        
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    c
                    n
                  
                  )
                
              
              )
            
          
          -
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    a
                    n
                  
                  )
                
              
              )
            
          
        
        }
      
    
    ≥
    
      4
      
        B
        
          n
          -
          1
        
      
    
  




From above




  
    d
    ⁡
    
      (
      
        
          z
          n
        
        ,
        
          z
          
            n
            +
            1
          
        
      
      )
    
  
  ≤
  
    1
    
      B
      
        n
        -
        1
      
    
  




implies that y (rn(an))<y(an) because





  
    
      y
      ⁡
      
        (
        
          c
          n
        
        )
      
    
    -
    
      y
      ⁡
      
        (
        
          a
          n
        
        )
      
    
  
  =
  
    
      4
      
        B
        
          n
          -
          1
        
      
    
    .
  




The inequality y(rn(an))<y(an) satisfies condition A in definition 1.8.

Condition B. in Definition 1.8
Similarly,




  
    
      y
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              d
              n
            
            )
          
        
        )
      
    
    -
    
      y
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              b
              n
            
            )
          
        
        )
      
    
  
  ≥
  
    
      4
      ⁢
      B
    
    
      B
      
        n
        -
        1
      
    
  




where B≧2 and m≧1.

Observe that




  
    y
    ⁡
    
      (
      
        z
        
          n
          +
          1
        
      
      )
    
  
  =
  
    
      1
      2
    
    ⁢
    
      
        {
        
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    d
                    n
                  
                  )
                
              
              )
            
          
          +
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    b
                    n
                  
                  )
                
              
              )
            
          
        
        }
      
      .
    
  




Thus,




  
    
      y
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              d
              n
            
            )
          
        
        )
      
    
    -
    
      y
      ⁡
      
        (
        
          z
          
            n
            +
            1
          
        
        )
      
    
  
  =
  
    
      
        1
        2
      
      ⁢
      
        {
        
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    d
                    n
                  
                  )
                
              
              )
            
          
          -
          
            y
            ⁡
            
              (
              
                
                  r
                  n
                
                ⁡
                
                  (
                  
                    b
                    n
                  
                  )
                
              
              )
            
          
        
        ]
      
    
    ≥
    
      4
      
        B
        
          n
          -
          1
        
      
    
  




From above




  
    d
    ⁡
    
      (
      
        
          z
          n
        
        ,
        
          z
          
            n
            +
            1
          
        
      
      )
    
  
  ≤
  
    1
    
      B
      
        n
        -
        1
      
    
  




implies y(rn(dn))>y(dn) because





  
    
      y
      ⁡
      
        (
        
          d
          n
        
        )
      
    
    -
    
      y
      ⁡
      
        (
        
          b
          n
        
        )
      
    
  
  =
  
    
      4
      
        B
        
          n
          -
          1
        
      
    
    .
  




The inequality y(rn(dn))>y(dn) satisfies condition B in definition 1.8.

Condition C. in Definition 1.8
Observe that




  
    
      x
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              b
              n
            
            )
          
        
        )
      
    
    -
    
      x
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              a
              n
            
            )
          
        
        )
      
    
  
  =
  
    
      
        1
        
          B
          m
        
      
      ⁢
      
        4
        
          B
          
            n
            -
            1
          
        
      
    
    ≤
    
      2
      
        B
        
          n
          -
          1
        
      
    
  




where B≧2 and m≧1.

And since




  
    x
    ⁡
    
      (
      
        z
        
          n
          +
          1
        
      
      )
    
  
  =
  
    
      
        
          1
          2
        
        ⁢
        
          {
          
            
              x
              ⁡
              
                (
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    
                      a
                      n
                    
                    )
                  
                
                )
              
            
            +
            
              x
              ⁡
              
                (
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    
                      b
                      n
                    
                    )
                  
                
                )
              
            
          
          }
        
        ⁢
        
          
        
        ⁢
        then
        ⁢
        
          
        
        ⁢
        
          x
          ⁡
          
            (
            
              z
              
                n
                +
                1
              
            
            )
          
        
      
      -
      
        x
        ⁡
        
          (
          
            
              r
              n
            
            ⁡
            
              (
              
                a
                n
              
              )
            
          
          )
        
      
    
    ≤
    
      
        1
        
          B
          
            n
            -
            1
          
        
      
      .
    
  




Thus,




  
    
      
        
          
          
            
              x
              ⁡
              
                (
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    
                      a
                      n
                    
                    )
                  
                
                )
              
            
            -
            
              x
              ⁡
              
                (
                
                  z
                  n
                
                )
              
            
          
          
        
        ≤
        
        ⁢
        
          
            
            
              
                x
                ⁡
                
                  (
                  
                    
                      r
                      n
                    
                    ⁡
                    
                      (
                      
                        a
                        n
                      
                      )
                    
                  
                  )
                
              
              -
              
                x
                ⁡
                
                  (
                  
                    z
                    
                      n
                      +
                      1
                    
                  
                  )
                
              
            
            
          
          +
          
            
            
              
                x
                ⁡
                
                  (
                  
                    z
                    
                      n
                      +
                      1
                    
                  
                  )
                
              
              -
              
                x
                ⁡
                
                  (
                  
                    z
                    n
                  
                  )
                
              
            
            
          
        
      
    
  
  
    
      
        ≤
        
        ⁢
        
          
            1
            
              B
              
                n
                -
                1
              
            
          
          +
          
            1
            
              B
              
                n
                -
                1
              
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          2
          
            B
            
              n
              -
              1
            
          
        
      
    
  




Since




  
    
      x
      ⁡
      
        (
        
          z
          n
        
        )
      
    
    -
    
      x
      ⁡
      
        (
        
          a
          n
        
        )
      
    
  
  =
  
    2
    
      B
      
        n
        -
        1
      
    
  




then x(rn(an))≧x(an) which satisfies condition C in 1.8

Condition D. in Definition 1.8
Observe that




  
    
      x
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              b
              n
            
            )
          
        
        )
      
    
    -
    
      x
      ⁡
      
        (
        
          
            r
            n
          
          ⁡
          
            (
            
              a
              n
            
            )
          
        
        )
      
    
  
  =
  
    
      
        1
        
          B
          m
        
      
      ⁢
      
        4
        
          B
          
            n
            -
            1
          
        
      
    
    ≤
    
      2
      
        B
        
          n
          -
          1
        
      
    
  




where B≧2 and m≧1.

And since




  
    x
    ⁡
    
      (
      
        z
        
          n
          +
          1
        
      
      )
    
  
  =
  
    
      
        
          1
          2
        
        ⁢
        
          {
          
            
              x
              ⁡
              
                (
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    
                      a
                      n
                    
                    )
                  
                
                )
              
            
            +
            
              x
              ⁡
              
                (
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    
                      b
                      n
                    
                    )
                  
                
                )
              
            
          
          }
        
        ⁢
        
          
        
        ⁢
        then
        ⁢
        
          
        
        ⁢
        
          x
          ⁡
          
            (
            
              
                r
                n
              
              ⁡
              
                (
                
                  b
                  n
                
                )
              
            
            )
          
        
      
      -
      
        x
        ⁡
        
          (
          
            z
            
              n
              +
              1
            
          
          )
        
      
    
    ≤
    
      
        1
        
          B
          
            n
            -
            1
          
        
      
      .
    
  




Thus,




  
    
      
        
          
          
            
              x
              ⁡
              
                (
                
                  
                    r
                    n
                  
                  ⁡
                  
                    (
                    
                      b
                      n
                    
                    )
                  
                
                )
              
            
            -
            
              x
              ⁡
              
                (
                
                  z
                  n
                
                )
              
            
          
          
        
        ≤
        
        ⁢
        
          
            
            
              
                x
                ⁡
                
                  (
                  
                    
                      r
                      n
                    
                    ⁡
                    
                      (
                      
                        b
                        n
                      
                      )
                    
                  
                  )
                
              
              -
              
                x
                ⁡
                
                  (
                  
                    z
                    
                      n
                      +
                      1
                    
                  
                  )
                
              
            
            
          
          +
          
            
            
              
                x
                ⁡
                
                  (
                  
                    z
                    
                      n
                      +
                      1
                    
                  
                  )
                
              
              -
              
                x
                ⁡
                
                  (
                  
                    z
                    n
                  
                  )
                
              
            
            
          
        
      
    
  
  
    
      
        ≤
        
        ⁢
        
          
            1
            
              B
              
                n
                -
                1
              
            
          
          +
          
            1
            
              B
              
                n
                -
                1
              
            
          
        
      
    
  
  
    
      
        =
        
        ⁢
        
          
            2
            
              B
              
                n
                -
                1
              
            
          
          .
        
      
    
  




Since




  
    
      x
      ⁡
      
        (
        
          b
          n
        
        )
      
    
    -
    
      x
      ⁡
      
        (
        
          z
          n
        
        )
      
    
  
  =
  
    2
    
      B
      
        n
        -
        1
      
    
  




then x(rn(bn))≦x(bn) which satisfies condition D in 1.8.

In the case where rn is of the form




  
    (
    
      
        
          
            B
            m
          
        
        
          0
        
      
      
        
          0
        
        
          
            1
            
              B
              m
            
          
        
      
    
    )
  
  ,




then conditions A., B., C., and D. of definition 1.10 are verified in a similar manner. Thus, for this particular n≧N, then rn has a fixed point in square [an, bn, cn, dn]⊂Wj. By theorems 1.13 and 1.14, the vertical and horizontal covering fixed point theorems respectively, rn has a fixed point which is an immortal periodic point.

Otherwise, for some M, for all n≧M, the linear part of rn is the identity




  
    (
    
      
        
          1
        
        
          0
        
      
      
        
          0
        
        
          1
        
      
    
    )
  
  .




Set U=maximum{M, N} where N was chosen above such that





  
    
      4
      ⁢
      
        2
      
    
    
      B
      
        N
        -
        1
      
    
  
  <
  
    
      δ
      2
    
    .
  




Set L=|Q∥A|(2U+1)+(2U+1). If there exists n≧L with rn(x, y)=(x, y), the proof is completed.

Otherwise, from 2.26 and 2.29, the program execution is unbounded on the left of the tape or the right of the tape or both. W.L.O.G. it is assumed that program execution is unbounded on the right. (The argument for unbounded on the left is similar.) Thus, when n≧L, then zn corresponds to the tape head being located at some position k, the tape contents are fixed at least n symbols in both directions from the tape square k and the machine is in some state q1. In other words, zn corresponds to













Tape Location



















k −

k −
k −
k −

k +
k +

k +




n
. . .
3
2
1
k
1
2
. . .
n






















Tape
bn
. . .
b3
b2
b1
a0
a1
a2
. . .
an
. . .


Contents


State





q1


(Tape head)









Since the program execution is unbounded on the right, for the next net L moves to the right on the tape, consider the state q when the tape head is located at tape square k+U+j for each j such that 0≦j≦L. By lemma 6.14, there are |Q|+1 distinct tape (2U+1)-strings that are identical where the tape head lies at a distinct tape location that is in the middle of this (2 U+1)-string. Since there are |Q| states, this means there are at least two of these strings that are identical and are also in the same state. Thus, there is an affine map r from the one identical (2U+1)-string (point v) to the other identical (2U+1)-string (point w); in other words, r(v)=w where map r's linear part is hyperbolic




   
  
    (
    
      
        
          
            B
            m
          
        
        
          0
        
      
      
        
          0
        
        
          
            1
            
              B
              m
            
          
        
      
    
    )
  




such that m≧1. Let [au, bv, cv, dv] be the square with center v and side length equal to





  
    4
    
      B
      U
    
  
  .




Thus, r(v)=w and





  
    d
    ⁡
    
      (
      
        v
        ,
        w
      
      )
    
  
  <
  
    1
    
      B
      U
    
  




implies that r([av, bv, cv, dv]) horizontally covers the square [av, bv, cv, dv]. By 1.14, r has a fixed point in [av, bv, cv, dv] which is an immortal periodic point.

The work in the previous proof yields a sharper result. In particular, if m, n≧L, then zm and zn are identical up to BL. Thus, the execution of the machine for the next net L tape head moves to the right are identical. Thus, the immortal orbit [p, ƒS(1)(p), . . . , ƒS(m) ƒS(m−1) . . . ƒS(2) ƒS(1)(p), . . . ] has a subsequence that converges to a fixed point in square [av, bv, cv, dv] with center v.
Remark 6.21 By making each of the (2U+1)-strings in theorem 6.20 at least m tape squares apart the horizontal covering rectangle or vertical covering rectangle can be made thinner than ε>0 where the fixed point lies inside the covering rectangle.
REFERENCES


    [1] G. Agnew. Random Source for Cryptographic Systems. Advances in Cryptology—EUROCRYPT 1987 Proceedings. Springer Verlag, 77-81 (1988)
    [2] P. Benioff. The computer as a physical system: A microscopic quantum mechanical Hamiltonian model of computers as represented by Turing machines. Journal of Statistical Physics. 22, 563-591 (1980)
    [3] P. Benioff. Quantum mechanical Hamiltonian models of Turing machines that dissipate no energy. Physics Review Letter. 48, 1581-1585 (1980)
    [4] Cristian S. Calude and Karl Svozil. Adv. Sci. Lett. 1, 165. (2008)
    [5] Cristian S. Calude, Michael J. Dinneen, Monica Dumitrescu, Karl Svozil. Experimental Evidence of Quantum Randomness Incomputability. Phys. Rev. A 82, 022102, 1-8 (2010)
    [6] Alonzo Church. An Unsolvable Problem of Elementary Number Theory. American Journal of Mathematics. 58, 345-363. (1936)
    [7] Martin Davis. Computability and Unsolvability. Dover Publications, New York, (1982)
    [8] David Deutsch. Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer. Proc. London Math. Soc. Series A. 400, No. 1818, 97-117 (1985)
    [9] Richard Feynman. Simulating physics with computers. International Journal of Theoretical Physics. 21, 467-488 (1982)
    [10] Richard Feynman. Quantum mechanical computers. Foundations of Physics. 16, 507-531 (1986)
    [11] Michael Stephen Fiske. Active Element Machine Computation. U.S. Pat. No. 8,010,467. (2007)
    [12] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W.H. Freeman, (1979)
    [13] L. K. Grover. Quantum mechanics helps in searching for a needle in a haystack. Physics Review Letters. 79, 325-328. (1997)
    [14] James M. Henle and Eugene M. Kleinberg. Infinitesimal Calculus. Mineola, N.Y. Dover Publications. (2003)
    [15] John Hertz, Anders Krogh and Richard G. Palmer. Introduction To The Theory of Neural Computation. Addison-Wesley Publishing Company. Redwood City, Calif., (1991)
    [16] John J. Hopfield. Neural networks and physical systems with emergent collective computational abilities. Proceedings of the National Academy of Sciences, USA. 79, 2554-2558. (1982)
    [17] John J. Hopfield and D. W. Tank. Neural Computation of Decisions in Optimization Problems. Biological Cybernetics. 52, 141-152. Springer Verlag (1985)
    [18] John J. Hopfield. Pattern recognition computation using action potential timing for stimulus representation. Nature. 376, 33-36. (1995)
    [19] Paul Kocher, Joshua Jaffe and Benjamin Jun. Advances in Cryptology—Crypto 99 Proceedings. Lecture Notes in Computer Science Volume 1666, M. Weiner, edited, Springer-Verlag (1999)
    [20] Harry R. Lewis and Christos H. Papadimitriou. Elements Of The Theory Of Computation. 222-223. Prentice-Hall (1981)
    [21] Yuri Manin. A Course in Mathematical Logic. Springer Verlag (1977)
    [22] Yuri Manin. Computable and Uncomputable (in Russian). Moscow, Sovetskoye Radio (1980)
    [23] Warren S. McCulloch, Walter Pitts. A logical calculus immanent in nervous activity. Bulletin of Mathematical Biophysics. 5, 115-133. (1943)
    [24] Marvin Minsky. Computation: Finite and Infinite Machines (1st edition). Englewood Cliffs, N.J. Prentice-Hall, Inc, (1967)
    [25] Marvin L. Minsky and Seymour A. Papert. Perceptrons. Cambridge, Mass. MIT Press, (1969)
    [26] Abraham Robinson. Non-standard Analysis. Revised Edition. Princeton, N.J. Princeton University Press, (1996)
    [27] Frank Rosenblatt. Two theorems of statistical separability in the perceptron. Proceedings of a Symposium on the Mechanization of Thought Processes, Her Majesty's Stationary Office, London, 421-456 (1959)
    [28] Claude Shannon. Communication Theory of Secrecy Systems. netlab.cs.edu/wiki/files/shannon1949.pdf. (1949)
    [29] Peter W. Shor. Algorithms for quantum computation: discrete log and factoring. Proceedings of the 35th Annual IEEE Symposium on Foundations of Computer Science. 2-22 (1994)
    [30] Andr'e Stefanov, Nicolas Gisin, Olivier Guinnard, Laurent Guinnard and Hugo Zbinden. Optical quantum random number generator. Journal of Modern Optics. 1362-3044, 47, 4, 595-598 (2000) http://arxiv.org/pdf/quant-ph/9907006
    [31] H. E. Sturgis, and J. C. Shepherdson. Computability of Recursive Functions. J. Assoc. Comput. Mach. 10, 217-255 (1963)
    [32] Alan M. Turing. On computable numbers, with an application to the Entscheidungsproblem. Proc. London Math. Soc. Series 2 42 (Parts 3 and 4), 230-265 (1936). A correction, ibid. 43, 544-546 (1937).









TABLE 1







Boolean Functions fk: {0, 1} × {0, 1} → {0, 1}








Function
AEM Separation Rule(s)





f1 =   




  
    (
    
      0
      ,
      0
      ,
      
        -
        1
      
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            0
            ,
            0
          
          )
        
        ,
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
    
      0
      /
    
  






 


f2 = ⊥




  
    (
    
      0
      ,
      0
      ,
      1
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      0
      /
    
    
      {
      
        
          (
          
            0
            ,
            0
          
          )
        
        ,
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
  






 


f3 = A




  
    (
    
      2
      ,
      0
      ,
      1
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            1
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            0
          
          )
        
      
      }
    
    
      {
      
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
  






 


f4 = B




  
    (
    
      0
      ,
      2
      ,
      1
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            1
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
      
      }
    
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
  






 


f5 =    A




  
    (
    
      
        -
        2
      
      ,
      0
      ,
      
        -
        1
      
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
    
      {
      
        
          (
          
            1
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            0
          
          )
        
      
      }
    
  






 


f6 =    B




  
    (
    
      0
      ,
      
        -
        2
      
      ,
      
        -
        1
      
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
    
      {
      
        
          (
          
            1
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
      
      }
    
  






 


f7 = A    B




  
    (
    
      2
      ,
      2
      ,
      3
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        (
        
          1
          ,
          1
        
        )
      
      }
    
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
  






 


f8 = A    B




  
    (
    
      2
      ,
      2
      ,
      1
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
    
      {
      
        (
        
          0
          ,
          0
        
        )
      
      }
    
  






 


f9 = A → B




  
    (
    
      
        -
        4
      
      ,
      2
      ,
      
        -
        3
      
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            0
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
    
      {
      
        (
        
          1
          ,
          0
        
        )
      
      }
    
  






 


f10 = A ← B




  
    (
    
      2
      ,
      
        -
        4
      
      ,
      
        -
        3
      
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            0
            ,
            0
          
          )
        
        ,
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
    
      {
      
        (
        
          0
          ,
          1
        
        )
      
      }
    
  






 


f11 = A    B
(2, −4, −3, Xk) and (−4, 2, −3, Xj) with j ≠ k


 


f12 =    (A    B)




  
    (
    
      
        -
        2
      
      ,
      
        -
        2
      
      ,
      
        -
        1
      
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        (
        
          0
          ,
          0
        
        )
      
      }
    
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
  






 


f13 =    (A    B)




  
    (
    
      
        -
        2
      
      ,
      
        -
        2
      
      ,
      
        -
        3
      
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            0
            ,
            0
          
          )
        
      
      }
    
    
      {
      
        (
        
          1
          ,
          1
        
        )
      
      }
    
  






 


f14 = A ⊕ B
(2, 2, 1, Xk) and (−2, −2, −3, Xj) with j ≠ k


 


f15 = A < B




  
    (
    
      
        -
        2
      
      ,
      4
      ,
      3
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        (
        
          0
          ,
          1
        
        )
      
      }
    
    
      {
      
        
          (
          
            0
            ,
            0
          
          )
        
        ,
        
          (
          
            1
            ,
            0
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
  






 


f16 = A > B




  
    (
    
      4
      ,
      
        -
        2
      
      ,
      3
      ,
      
        X
        k
      
    
    )
  
  ↔
  
    
      {
      
        (
        
          1
          ,
          0
        
        )
      
      }
    
    
      {
      
        
          (
          
            0
            ,
            0
          
          )
        
        ,
        
          (
          
            0
            ,
            1
          
          )
        
        ,
        
          (
          
            1
            ,
            1
          
          )
        
      
      }
    
  




















TABLE 2







Minsky Universal Turing Machine with Program η














y
0
1
A







q1
(q1, 0, L)
(q1, 0, L)
(q2, 1, L)
(q1, 1, L)



q2
(q1, 0, L)
(q2, y, R) 
(q2, A, R)
(q6, y, R)



q3
(q3, y, L) 
(h, 0, h)
(q3, A, L) 
(q4, 1, L)



q4
(q4, y, L) 
(q5, y, R)
(q7, 1, L)
(q4, 1, L)



q5
(q5, y, R) 
(q3, y, L) 
(q5, A, R) 
(q5, 1, R)



q6
(q6, y, R) 
(q3, A, L)
(q6, A, R) 
(q6, 1, R)



q7
(q7, 0, R) 
(q6, y, R) 
(q7, 1, R) 
(q2, 0, R)







State set Q = {q1, q2, q3, q4, q5, q6, q7}.



Alphabet A = {y, 0, 1, A}.













TABLE 3







Boolean Universal Turing Machine program η =


( η0 η1 η2, η3 η4, η5)












10
00
01
11





001
(001, 00, 0)
(001, 00, 0)
(010, 01, 0)
(001, 01, 0)


010
(001, 00, 0)
(010, 10, 1)
(010, 11, 1)
(110, 10, 1)


011
(011, 10, 0)
(000, 00, h)
(011, 11, 0)
(100, 01, 0)


100
(100, 10, 0)
(101, 10, 1)
(111, 01, 0)
(100, 01, 0)


101
(101, 10, 1)
(011, 10, 0)
(101, 11, 1)
(101, 01, 1)


110
(110, 10, 1)
(011, 11, 0)
(110, 11, 1)
(110, 01, 1)


111
(111, 00, 1)
(110, 10, 1)
(111, 01, 1)
(010, 00, 1)





State set Q = {001, 010, 011, 100, 101, 110, 111 }.


A = {10, 00, 01, 11}.













TABLE 4







AEM Separation Rules for Level Set η0−1{1}














Fire









Pattern
Element
(U, Ai)
(W, Ai)
(X, Ai)
(Y, Ai)
(Z, Ai)
θAi

















111 10
A0
2
2
2
2
−2
7


111 01
A1
2
2
2
−2
2
7


111 00
A2
2
2
2
−2
−2
5


110 11
A3
2
2
−2
2
2
7


110 10
A4
2
2
−2
2
−2
5


110 01
A5
2
2
−2
−2
2
5


101 11
A6
2
−2
2
2
2
7


101 10
A7
2
−2
2
2
−2
5


101 01
A8
2
−2
2
−2
2
5


100 11
A9
2
−2
−2
2
2
5


100 10
A10
2
−2
−2
2
−2
3


100 01
A11
2
−2
−2
−2
2
3


100 00
A12
2
−2
−2
−2
−2
1


011 11
A13
−2
2
2
2
2
7


010 11
A14
−2
2
−2
2
2
5
















TABLE 5







AEM Separation Rules for Level Set η1−1{1}














Fire









Pattern
Element
(U, Bi)
(W, Bi)
(X, Bi)
(Y, Bi)
(Z, Bi)
θBi

















111 11
B0
2
2
2
2
2
9


111 10
B1
2
2
2
2
−2
7


111 01
B2
2
2
2
−2
2
7


111 00
B3
2
2
2
−2
−2
5


110 11
B4
2
2
−2
2
2
7


110 10
B5
2
2
−2
2
−2
5


110 01
B6
2
2
−2
−2
2
5


110 00
B7
2
2
−2
−2
−2
3


101 00
B8
2
−2
2
−2
−2
3


100 01
B9
2
−2
−2
−2
2
3


011 10
B10
−2
2
2
2
−2
5


011 01
B11
−2
2
2
−2
2
5


010 11
B12
−2
2
−2
2
2
5


010 01
B13
−2
2
−2
−2
2
3


010 00
B14
−2
2
−2
−2
−2
1


001 01
B15
−2
−2
2
−2
2
3
















TABLE 6







AEM Separation Rules for Level Set η2−1{1}














Fire









Pattern
Element
(U, Ci)
(W, Ci)
(X, Ci)
(Y, Ci)
(Z, Ci)
θCi

















111 10
C0
2
2
2
2
−2
7


111 01
C1
2
2
2
−2
2
7


110 00
C2
2
2
−2
−2
−2
3


101 11
C3
2
−2
2
2
2
7


101 10
C4
2
−2
2
2
−2
5


101 01
C5
2
−2
2
−2
2
5


101 00
C6
2
−2
2
−2
−2
3


100 01
C7
2
−2
−2
−2
2
3


100 00
C8
2
−2
−2
−2
−2
1


011 10
C9
−2
2
2
2
−2
5


011 01
C10
−2
2
2
−2
2
5


010 10
C11
−2
2
−2
2
−2
3


001 11
C12
−2
−2
2
2
2
5


001 10
C13
−2
−2
2
2
−2
3


001 00
C14
−2
−2
2
−2
−2
1
















TABLE 7







AEM Separation Rules for Level Set η3−1{1}














Fire









Pattern
Element
(U, Di)
(W, Di)
(X, Di)
(Y, Di)
(Z, Di)
θDi

















111 00
D0
2
2
2
−2
−2
5


110 00
D1
2
2
−2
−2
−2
3


110 01
D2
2
2
−2
−2
2
5


110 10
D3
2
2
−2
2
−2
5


101 00
D4
2
−2
2
−2
−2
3


101 01
D5
2
−2
2
−2
2
5


101 10
D6
2
−2
2
2
−2
5


100 00
D7
2
−2
−2
−2
−2
1


100 10
D8
2
−2
−2
2
−2
3


011 01
D9
−2
2
2
−2
2
5


011 10
D10
−2
2
2
2
−2
5


010 00
D11
−2
2
−2
−2
−2
1


010 01
D12
−2
2
−2
−2
2
3


010 11
D13
−2
2
−2
2
2
5
















TABLE 8







AEM Separation Rules for Level Set η4−1{1}














Fire









Pattern
Element
(U, Ei)
(W, Ei)
(X, Ei)
(Y, Ei)
(Z, Ei)
θEi

















111 01
E0
2
2
2
−2
2
7


110 11
E1
2
2
−2
2
2
7


110 01
E2
2
2
−2
−2
2
5


110 00
E3
2
2
−2
−2
−2
3


101 11
E4
2
−2
2
2
2
7


101 01
E5
2
−2
2
−2
2
5


100 11
E6
2
−2
−2
2
2
5


100 01
E7
2
−2
−2
−2
2
3


011 11
E8
−2
2
2
2
2
7


011 01
E9
−2
2
2
−2
2
5


010 01
E10
−2
2
−2
−2
2
3


001 11
E11
−2
−2
2
2
2
5


001 01
E12
−2
−2
2
−2
2
3
















TABLE 9







AEM Separation Rules for Level Set η5−1{1}














Fire









Pattern
Element
(U, Fi)
(W, Fi)
(X, Fi)
(Y, Fi)
(Z, Fi)
θFi

















111 11
F0
2
2
2
2
2
9


111 10
F1
2
2
2
2
−2
7


111 01
F2
2
2
2
−2
2
7


111 00
F3
2
2
2
−2
−2
5


110 11
F4
2
2
−2
2
2
7


110 10
F5
2
2
−2
2
−2
5


110 01
F6
2
2
−2
−2
2
5


101 11
F7
2
−2
2
2
2
7


101 10
F8
2
−2
2
2
−2
5


101 01
F9
2
−2
2
−2
2
5


100 00
F10
2
−2
−2
−2
−2
1


010 11
F11
−2
2
−2
2
2
5


010 01
F12
−2
2
−2
−2
2
3


010 00
F13
−2
2
−2
−2
−2
1
















TABLE 10







Adding Four Bits: X0, X1, X2, X3

















X0
X1
X2
X3
C0
C1
C2
C3
P0
P1
P2





0
0
0
0
0
0
0
0
0
0
0


0
0
0
1
1
0
0
0
1
0
0


0
0
1
0
1
0
0
0
1
0
0


0
1
0
0
1
0
0
0
1
0
0


1
0
0
0
1
0
0
0
1
0
0


0
0
1
1
1
1
0
0
0
1
0


0
1
0
1
1
1
0
0
0
1
0


1
0
0
1
1
1
0
0
0
1
0


0
1
1
0
1
1
0
0
0
1
0


1
0
1
0
1
1
0
0
0
1
0


1
1
0
0
1
1
0
0
0
1
0


0
1
1
1
1
1
1
0
1
1
0


1
0
1
1
1
1
1
0
1
1
0


1
1
0
1
1
1
1
0
1
1
0


1
1
1
0
1
1
1
0
1
1
0


1
1
1
1
1
1
1
1
0
0
1
















TABLE 11







Adding Four Bits: Xk to Cj Amplitudes and Cj Thresholds















Ele-










ment
(Xk, C0)
(Xk, C1)
(Xk, C2)
(Xk, C3)
θC0
θC1
θC2
θC3





Xk
2
2
2
2
1
3
5
7





k index refers to X0, X1, X2, X3













TABLE 12





Adding Four Bits: Cj to Pi Amplitudes






















Element
(C0, P0)
(C1, P0) 
(C2, P0)
(C3, P0)
θP0







P0
2
−2
2
−2
1







Element
(C0, P1)
(C1, P1) 
(C2, P1)
(C3, P1) 
θP1







P1
0
2
2
−4
1







Element
(C0, P2)
(C1, P2)
(C2, P2) 
(C3, P2) 
θP2







P2
2
2
2
2
7

















TABLE 13





Four Bit Multiplication


























y3
y2
y1
y0





*
z3
z2
z1
z0






y3z0
y2z0
y1z0
y0z0





y3z1
y2z1
y1z1
y0z1




y3z2
y2z2
y1z2
y0z2



y3z3
y2z3
y1z3
y0z3


e7
e6
e5
e4
e3
e2
e1
e0
















TABLE 14







Element E0 represents bit e0. Amplitude and Threshold









(Y0, E0)
(Z0, E0)
θE0





2
2
3
















TABLE 15







e1 Bit. S10    y1z0. S01    y0z1.












S10
S01
C01
C11







0
0
0
0



0
1
1
0



1
0
1
0



1
1
1
1

















TABLE 16





e1 Bit. Sjk to Cil Amplitudes and Cil Thresholds




















(S01, C01)
(S01, C11)
(S10, C01)
(S10, C11)
θC01
θC11


2
2
2
2
1
3
















TABLE 17





Element E1 represents bit e1.


Amplitude and Threshold



















(C01, E1)
(C11, E1)
θE1



2
−2
1

















TABLE 18







e2 Bit. S20   y2z0. S11   y1z1. S02   y0z2.

















S20
S11
S02
C11
C02
C12
C22
C32
P02
P12
P22





0
0
0
0
0
0
0
0
0
0
0


0
0
0
1
0
0
0
0
1
0
0


0
0
1
0
1
0
0
0
1
0
0


0
1
0
0
1
0
0
0
1
0
0


1
0
0
0
1
0
0
0
1
0
0


0
0
1
1
1
1
0
0
0
1
0


0
1
0
1
1
1
0
0
0
1
0


1
0
0
1
1
1
0
0
0
1
0


0
1
1
0
1
1
0
0
0
1
0


1
0
1
0
1
1
0
0
0
1
0


1
1
0
0
1
1
0
0
0
1
0


0
1
1
1
1
1
1
0
1
1
0


1
0
1
1
1
1
1
0
1
1
0


1
1
0
1
1
1
1
0
1
1
0


1
1
1
0
1
1
1
0
1
1
0


1
1
1
1
1
1
1
1
0
0
1
















TABLE 19







e2 Bit. Sjk, C11 to Ci2 Amplitudes and Ci2 Thresholds














(Sjk,
(Sjk,
(Sjk,
(Sjk,






C02)
C12)
C22)
C32)
θC02
θC12
θC22
θC32





2
2
2
2
1
3
5
7
















TABLE 20





Cj2 to Pi2 Amplitudes and Pi2 Thresholds




















Element
(C02, P02)
(C12, P02)
(C22, P02)
(C32, P02)
θP02


P02
2
−2
2
−2
1


Element
(C02, P12)
(C12, P12)
(C22, P12)
(C32, P12)
θP12


P12
0
2
2
−4
1


Element
(C02, P22)
(C12, P22)
(C22, P22)
(C32, P22)
θP22


P22
2
2
2
2
7
















TABLE 21





Element E2 represents bit e2.


Amplitude and Threshold


















(P02, E2)
θE2



2
1

















TABLE 22







e3 Bit. Sjk   yjzk where j + k = 3.



















S30
S21
S12
S03
P12
C03
C13
C23
C33
C43
P03
P13
P23





0
0
0
0
0
0
0
0
0
0
0
0
0


0
0
0
0
1
1
0
0
0
0
1
0
0


0
0
0
1
0
1
0
0
0
0
1
0
0


0
0
1
0
0
1
0
0
0
0
1
0
0


0
1
0
0
0
1
0
0
0
0
1
0
0


1
0
0
0
0
1
0
0
0
0
1
0
0


1
0
0
0
1
1
1
0
0
0
0
1
0


0
1
0
0
1
1
1
0
0
0
0
1
0


0
0
1
0
1
1
1
0
0
0
0
1
0


0
0
0
1
1
1
1
0
0
0
0
1
0


0
0
1
1
0
1
1
0
0
0
0
1
0


0
1
0
1
0
1
1
0
0
0
0
1
0


1
0
0
1
0
1
1
0
0
0
0
1
0


0
1
1
0
0
1
1
0
0
0
0
1
0


1
0
1
0
0
1
1
0
0
0
0
1
0


1
1
0
0
0
1
1
0
0
0
0
1
0


0
0
1
1
1
1
1
1
0
0
1
1
0


0
1
0
1
1
1
1
1
0
0
1
1
0


1
0
0
1
1
1
1
1
0
0
1
1
0


0
1
1
0
1
1
1
1
0
0
1
1
0


1
1
0
0
1
1
1
1
0
0
1
1
0


0
1
1
1
0
1
1
1
0
0
1
1
0


1
0
1
1
0
1
1
1
0
0
1
1
0


1
1
0
1
0
1
1
1
0
0
1
1
0


1
0
1
0
1
1
1
1
0
0
1
1
0


1
1
1
0
0
1
1
1
0
0
1
1
0


0
1
1
1
1
1
1
1
1
0
0
0
1


1
0
1
1
1
1
1
1
1
0
0
0
1


1
1
0
1
1
1
1
1
1
0
0
0
1


1
1
1
0
1
1
1
1
1
0
0
0
1


1
1
1
1
0
1
1
1
1
0
0
0
1


1
1
1
1
1
1
1
1
1
1
1
0
1
















TABLE 23





Sjk (j + k = 3). Sjk to Ci3 connections and Ci3 thresholds.




















(Sjk, Ci3)
θC03
θC13
θC23
θC33
θC43


2
1
3
5
7
9
















TABLE 24





Cj3 to Pi3 Amplitudes and Pi3 Thresholds




















(C03, P03)
(C13, P03)
(C23, P03)
(C33, P03)
(C43, P03)
θP03


2
−2
2
−2
2
1


(C03, P13)
(C13, P13)
(C23, P13)
(C33, P13)
(C43, P13)
θP13


0
2
2
−4
0
1


(C03, P23)
(C13, P23)
(C23, P23)
(C33, P23)
(C43, P23)
θP23


2
2
2
2
2
7
















TABLE 25





Element E3 represents bit e3.


Sjk (j + k = 3).


















(P03, E3)
θE3



2
1

















TABLE 26







e4 Bit. S31   y3z1. S22   y2z2. S13   y1z3.



















S31
S22
S13
P22
P13
C04
C14
C24
C34
C44
P04
P14
P24





0
0
0
0
0
0
0
0
0
0
0
0
0


0
0
0
0
1
1
0
0
0
0
1
0
0


0
0
0
1
0
1
0
0
0
0
1
0
0


0
0
1
0
0
1
0
0
0
0
1
0
0


0
1
0
0
0
1
0
0
0
0
1
0
0


1
0
0
0
0
1
0
0
0
0
1
0
0


1
0
0
0
1
1
1
0
0
0
0
1
0


0
1
0
0
1
1
1
0
0
0
0
1
0


0
0
1
0
1
1
1
0
0
0
0
1
0


0
0
0
1
1
1
1
0
0
0
0
1
0


0
0
1
1
0
1
1
0
0
0
0
1
0


0
1
0
1
0
1
1
0
0
0
0
1
0


1
0
0
1
0
1
1
0
0
0
0
1
0


0
1
1
0
0
1
1
0
0
0
0
1
0


1
0
1
0
0
1
1
0
0
0
0
1
0


1
1
0
0
0
1
1
0
0
0
0
1
0


0
0
1
1
1
1
1
1
0
0
1
1
0


0
1
0
1
1
1
1
1
0
0
1
1
0


1
0
0
1
1
1
1
1
0
0
1
1
0


0
1
1
0
1
1
1
1
0
0
1
1
0


1
1
0
0
1
1
1
1
0
0
1
1
0


0
1
1
1
0
1
1
1
0
0
1
1
0


1
0
1
1
0
1
1
1
0
0
1
1
0


1
1
0
1
0
1
1
1
0
0
1
1
0


1
0
1
0
1
1
1
1
0
0
1
1
0


1
1
1
0
0
1
1
1
0
0
1
1
0


0
1
1
1
1
1
1
1
1
0
0
0
1


1
0
1
1
1
1
1
1
1
0
0
0
1


1
1
0
1
1
1
1
1
1
0
0
0
1


1
1
1
0
1
1
1
1
1
0
0
0
1


1
1
1
1
0
1
1
1
1
0
0
0
1


1
1
1
1
1
1
1
1
1
1
1
0
1
















TABLE 27







e4 Bit. Sjk to Ci4 Amplitudes and Ci4 Thresholds














(Sjk, Ci4)
(P22, Ci4)
(P13, Ci4)
θC04
θC14
θC24
θC34
θC44





2
2
2
1
3
5
7
9
















TABLE 28





Cj4 to Pi4 Amplitudes and Pi4 Thresholds




















(C04, P04)
(C14, P04)
(C24, P04)
(C34, P04)
(C44, P04)
θP04


2
−2
2
−2
2
1


(C04, P14)
(C14, P14)
(C24, P14)
(C34, P14)
(C44, P14)
θP14


0
2
2
−4
0
1


(C04, P24)
(C14, P24)
(C24, P24)
(C34, P24)
(C44, P24)
θP24


2
2
2
2
2
7
















TABLE 29





Element E4 represents bit e4.


Sjk (j + k = 4).


















(P04, E4)
θE4



2
1

















TABLE 30







e5 Bit. S32   y3z2. S23   y2z3.

















S32
S23
P14
P23
C05
C15
C25
C35
P05
P15
P25





0
0
0
0
0
0
0
0
0
0
0


0
0
0
1
0
0
0
0
1
0
0


0
0
1
0
1
0
0
0
1
0
0


0
1
0
0
1
0
0
0
1
0
0


1
0
0
0
1
0
0
0
1
0
0


0
0
1
1
1
1
0
0
0
1
0


0
1
0
1
1
1
0
0
0
1
0


1
0
0
1
1
1
0
0
0
1
0


0
1
1
0
1
1
0
0
0
1
0


1
0
1
0
1
1
0
0
0
1
0


1
1
0
0
1
1
0
0
0
1
0


0
1
1
1
1
1
1
0
1
1
0


1
0
1
1
1
1
1
0
1
1
0


1
1
0
1
1
1
1
0
1
1
0


1
1
1
0
1
1
1
0
1
1
0


1
1
1
1
1
1
1
1
0
0
1
















TABLE 31







e5 Bit. Sjk, P14 and P23 to Ci5 Amplitudes and Ci5 Thresholds














(S32,
(S23,
(P14,
(P23,






Ci5)
Ci5)
Ci5)
Ci5)
θC05
θC15
θC25
θC35





2
2
2
2
1
3
5
7
















TABLE 32





Cj5 to Pi5 Amplitudes and Pi5 Thresholds





















(C05, P05)
(C15, P05)
(C25, P05)
(C35, P05)
θP05



2
−2
2
−2
1



(C05, P15)
(C15, P15)
(C25, P15)
(C35, P15)
θP15



0
2
2
−4
1



(C05, P25)
(C15, P25)
(C25, P25)
(C35, P25)
θP25



2
2
2
2
7

















TABLE 33





Element E5 represents bit e5.


Sjk (j + k = 5).


















(P05, E5)
θE5



2
1

















TABLE 34







e6 Bit. S33   y3z3
















S33
P15
P24
C06
C16
C26
P06
P16







0
0
0
0
0
0
0
0



0
0
1
1
0
0
1
0



0
1
0
1
0
0
1
0



1
0
0
1
0
0
1
0



0
1
1
1
1
0
0
1



1
0
1
1
1
0
0
1



1
1
0
1
1
0
0
1



1
1
1
1
1
1
1
1

















TABLE 35





e6 Bit. Sjk to Ci6 Amplitudes and Ci6 Thresholds




















(S33, Ci6)
(P15, Ci6)
(P24, Ci6)
θC06
θC16
θC26


2
2
2
1
3
5
















TABLE 36





Cj6 to Pi6 Amplitudes and Pi6 Thresholds




















(C06, P06)
(C16, P06)
(C26, P06)
θP06



2
−2
2
1



(C06, P16)
(C16, P16)
(C26, P16)
θP16



0
2
2
1

















TABLE 37





Element E6 represents bit e6.


Amplitude and Threshold


















(P06, E6)
θE6



2
1

















TABLE 38





Four Bit Multiplication. 1110 * 0111




























1
1
1
0






*
0
1
1
1







1
1
1
0






1
1
1
0





1
1
1
0




0
0
0
0




1
1
0
0
0
1
0



e7
e6
e5
e4
e3
e2
e1
e0







14 * 7 = 98 in Base 10.













TABLE 39





Four Bit Multiplication. 1011 * 1001




























1
0
1
1






*
1
0
0
1







1
0
1
1






0
0
0
0





0
0
0
0




1
0
1
1




1
1
0
0
0
1
1



e7
e6
e5
e4
e3
e2
e1
e0







11 * 9 = 99 in Base 10.













TABLE 40





Four Bit Multiplication. 1111 * 1110




























1
1
1
1






*
1
1
1
0







1
1
1
0






1
1
1
0





1
1
1
0




0
0
0
0



1
1
0
1
0
0
1
0



e7
e6
e5
e4
e3
e2
e1
e0







15 * 14 = 210 in Base 10.













TABLE 41





Four Bit Multiplication. 1111 * 1111




























1
1
1
1






*
1
1
1
1







1
1
1
1






1
1
1
1





1
1
1
1




1
1
1
1



1
1
1
0
0
0
0
1



e7
e6
e5
e4
e3
e2
e1
e0







15 * 15 = 225 in Base 10.

## Claims

1. A machine implemented method of executing a computer program comprising:
creating, by the machine, a representation for executing a program instruction on the machine, the machine including a plurality of communicatively coupled computing elements that communicate with one another;
executing, by the machine, the program instruction, in the representation at the machine;
modifying, by the plurality of computing elements, the representation for executing the program instruction on the machine; and
executing, by the machine, the program instruction in the representation after representation has been modified;
wherein one or more program instructions executed at distinct instances are executed without using fixed representations; and
wherein said machine has an unbounded prime directed edge complexity.

2. The method of claim 1 wherein said distinct instances are different times.

3. A machine implemented method of executing a computer program comprising:
creating, by the machine, a representation for executing a program instruction on the machine, the machine including a plurality of communicatively coupled computing elements that communicate with one another;
executing, by the machine, the program instruction, in the representation at the machine;
modifying, by the plurality of computing elements, the representation for executing the program instruction on the machine; and
executing, by the machine, the program instruction in the representation after representation has been modified;
wherein said distinct instances are at different parts of the machine executing said computer program.

4. The method of claim 3 wherein said one or more program instructions add numbers.

5. The method of claim 3 wherein said one or more program instructions help multiply numbers.

6. The method of claim 3 further comprising:
prior to the modifying, determining a new representation based on a random determination, the modifying of the representation creates the new representation, wherein randomness helps determine how said one or more program instructions are executed without using fixed representations.

7. The method of claim 6 wherein said randomness is quantum.

8. The method of claim 7 wherein said quantum randomness is produced with photons or by a semiconductor material.

9. A machine implemented method of executing a computer program comprising:
creating, by the machine, a representation for executing a program instruction on the machine, the machine including a plurality of communicatively coupled computing elements that communicate with one another;
executing, by the machine, the program instruction, in the representation at the machine;
modifying, by the plurality of computing elements, the representation for executing the program instruction on the machine; and
executing, by the machine, the program instruction in the representation after representation has been modified;
wherein one or more program instructions executed at distinct instances are executed without using fixed representations wherein dynamic interpretations help execute said one or more program instructions without using fixed representation, dynamic interpretations being multiple firing patterns that each perform the execution of the instruction.

10. The method of claim 9 wherein said computer program is a digital computer program.

11. The method of claim 9 wherein one or more said computer program instructions use time as a parameter.

12. The method of claim 10 wherein said computer program is expressed in one or more of the following languages: C, JAVA, C++, Fortran, assembly language, Ruby, Forth, LISP, Haskell, RISC machine instructions, javascript, java virtual machine, Python, Turing machine.

13. The method of claim 9 wherein said one or more program instructions are executed with a machine comprising a multiplicity of computing elements; and a multiplicity of couplings communicatively connecting the multiplicity of computing elements to one another, such that the couplings are capable of transmitting messages between the multiplicity of computing elements.

14. A machine implemented method of executing a computer program comprising:
creating, by the machine, a representation for executing a program instruction on the machine, the machine including a plurality of communicatively coupled computing elements that communicate with one another;
executing, by the machine, the program instruction, in the representation at the machine;
modifying, by the plurality of computing elements, the representation for executing the program instruction on the machine; and
executing, by the machine, the program instruction in the representation after representation has been modified;
wherein one or more program instructions executed at distinct instances are executed without using fixed representations;
wherein said one or more program instructions are executed with a machine including at least a multiplicity of computing elements; and a multiplicity of couplings communicatively connecting the multiplicity of computing elements to one another, such that the couplings are capable of transmitting messages between the multiplicity of computing elements; and
wherein said couplings are expressed by one or more connection commands.

15. The method of claim 14 wherein said one or more program instructions are executed with a system comprising a multiplicity of computing elements; and a multiplicity of couplings communicatively connecting the multiplicity of computing elements to one another, such that the couplings are capable of transmitting messages between the multiplicity of computing elements.

16. The method of claim 2 wherein said different times are indicated by one or more commands.

17. The method of claim 16 wherein said one or more commands include at least one meta command.

18. The method of claim 16 wherein said one or more commands include at least one connection or element command.

19. The method of claim 6 wherein said randomness is generated by a physical process.

20. The method of claim 19 wherein said physical process occurs inside a physical barrier that contains an active element machine or inside a chip that executes an active element machine.

21. The method of claim 19 wherein said physical process comes from the environment.

22. A machine comprising:
a plurality of computing elements communicatively coupled to one another that send messages to one another,
the machine storing machine one or more machine instructions, which when executed cause the machine to perform a method including at least
creating, by the machine, a representation for executing a program instruction on the machine;
executing, by the machine, the program instruction, in the representation at the machine;
modifying, by the plurality of computing elements, the representation for executing the program instruction on the machine; and
executing, by the machine, the program instruction in the representation after representation has been modified;

wherein one or more program instructions executed at distinct instances are executed without using fixed representations;
the plurality of computing elements forming a network; and each element sends a message to another computing element when inputs to the computing element meet a particular criteria, modifying the representation includes modifying when messages are sent between computing elements.

23. The machine of claim 22 wherein said computer program is expressed in one or more of the following languages: C, JAVA, C++, Fortran, assembly language, Ruby, Forth, LISP, Haskell, RISC machine instructions, javascript, java virtual machine, Python, Turing machine, which is translated into machine instructions for the plurality of computing elements, each machine instruction determining a configuration of a computing element or connection between computing elements.

24. The machine of claim 22 wherein said distinct instances are different times.

25. The machine of claim 22 wherein said distinct instances use different parts of the computing machine.

26. The machine of claim 22 wherein said computer program is an active element machine program.

27. The machine of claim 22 wherein randomness is used to help differently compute said program instruction(s).

28. The machine of claim 22 wherein said program instruction(s) can be expressed as one or more Boolean functions.

29. A machine comprising:
a plurality of computing elements communicatively coupled to one another that send messages to one another,
the machine storing machine one or more machine instructions, which when executed cause the machine to perform a method including at least
creating, by the machine, a representation for executing a program instruction on the machine;
executing, by the machine, the program instruction, in the representation at the machine;
modifying, by the plurality of computing elements, the representation for executing the program instruction on the machine; and
executing, by the machine, the program instruction in the representation after representation has been modified;

wherein one or more program instructions executed at distinct instances are executed without using fixed representations;
wherein said machine has an unbounded prime directed edge complexity.

30. The machine of claim 29 wherein said machine's execution has no recurrent configurations.

31. A machine comprising
a plurality of computing elements commutatively coupled to one another that send messages to one another, the machine storing instructions, which when executed cause the machine to perform the method including at least performing an edge pattern substitution by at least moving, by the machine, a virtual read head to a first virtual execution node;
reading by the machine, content of the virtual execution node;
determining, by the plurality of computing elements, whether a portion of content of a virtual tail node matches at least a portion of content in the execution node;

and
if the portion of content of the virtual tail node matches the portion of the content of the virtual execution node,
selecting, by the machine, content from a virtual head node; and
replacing, by the machine, the portion of virtual execution node with content from the virtual head node, the virtual head node and the virtual tail node having a pre-existing association with one another;



moving, by the machine, the virtual read head to a second virtual execution node, which execution node is the second execution node being determined based on edge pattern substitution;
wherein edge pattern substitution is used to execute a computer program.

32. The machine of claim 31 wherein said machine finds prime directed edges.

33. The machine of claim 32 wherein said prime directed edges are derived from a computer program.

34. The machine of claim 31 that compiles a computer program into a set of prime directed edges.

35. A machine implemented method of executing a computer program comprising:
performing an edge pattern substitution by at least
moving, by the machine, a virtual read head to a first virtual execution node, the machine including at least a plurality of computing elements commutatively coupled to one another that send messages to one another;
reading by the machine, content of the virtual execution node;
determining, by the plurality of computing elements, whether a portion of content of a virtual tail node matches at least a portion of content in the execution node;
and
if the portion of content of the virtual tail node matches the portion of the content of the virtual execution node,
selecting, by the machine, content from a virtual head node; and
replacing, by the machine, the portion of virtual execution node with content from the virtual head node, the virtual head node and the virtual tail node having a pre-existing association with one another; and

moving, by the machine, the virtual read head to a second virtual execution node, which execution node is the second execution node being determined based on edge patter substitution.

36. The method of claim 35 wherein said method finds prime directed edges.

37. A machine implemented method of computing a Boolean function using level sets comprising:
separating, by the machine, a domain of a Boolean function into four members, the machine including at least a plurality of computing elements commutatively coupled to one another that send messages to one another;
determining, by the plurality of computing elements, an active element tuple containing parameters for each active element;
creating, by the machine, one or more separation rules based on the domain of the Boolean function and an active element;
for each active element, based on one of the separation rules, mapping, by the machine, a level set of the Boolean function and tuple to a unique active element firing pattern; and
computing, by the machine, a Boolean function based on the level set mapping.

38. The method of claim 37 wherein an active element machine computes said Boolean function.

39. The method of claim 38 wherein parameter values of said active element machine are chosen to separate said level sets.

40. The method of claim 38 wherein said active element machine differently computes said Boolean function at distinct instances.

41. The method of claim 40 wherein different parameter values are used to differently compute said Boolean function at distinct instances.

42. A machine implemented method of computing a Boolean function with an active element machine comprising:
separating, by a machine, a domain of a Boolean function into four members, the machine including at least a network of computing elements commutatively coupled to one another that send messages to one another, a representation of instructions determining when the messages are sent;
determining, by the plurality of computing elements, an active element tuple containing parameters for each active element;
creating, by the machine, a separation rule based on the domain of the Boolean functions and an active element;
for each active element, based on one of the separation rules mapping a level set of the Boolean function and tuple to one of the unique active element firing patterns; and
computing a Boolean function based on the level set mapping.

43. The method of claim 42 wherein said Boolean function multiplies two numbers.

44. The method of claim 42 wherein said Boolean function helps execute a program instruction in a computer program.

45. The method of claim 42 wherein one or more members in the same level set of the Boolean function are expressed with a pattern established during a window of time.

46. A machine implemented method of executing a computer program comprising:
creating, by the machine, a representation for executing a program instruction on the machine, the machine including a plurality of communicatively coupled computing elements that communicate with one another;
executing, by the machine, the program instruction, in the representation at the machine;
modifying, by the plurality of computing elements, the representation for executing the program instruction on the machine, the modification being determined based on a random event; and
executing, by the machine, the program instruction in the representation after representation has been modified;
wherein randomness is used to help execute computer program instructions; and
wherein said machine has an unbounded prime directed edge complexity.

47. The method of claim 46 wherein said randomness is quantum.

48. The method of claim 46 wherein said randomness helps determine how at least one said program instruction is computed differently at different instances.

49. The method of claim 48 wherein said distinct instances are different times.

50. The method of claim 48 wherein said distinct instances are at different parts of a machine executing said program instruction.

51. The method of claim 46 wherein said randomness is produced by a physical process.

52. The method of claim 48 wherein said program instruction is executed with an active element machine.

53. The method of claim 52 wherein said randomness helps determine element or connection parameter values in said machine.

54. The method of claim 48 wherein dynamic interpretations execute said one or more program instructions without using fixed representation, dynamic interpretations being multiple firing patterns that can be used to perform the same task.

55. The method of claim 48 wherein randomness helps determine a firing pattern during a window of time.

56. The method of claim 55 wherein one or more members in the same level set are expressed with said firing pattern.