Patent Grant
10268843
The specification generally relates to computing.
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.
(0
0)=1.
(1
0)=1.
(0
1)=1.
(1
1)=0.
1
For each boolean function ƒ: {0, 1}×{0, 1}→{0, 1},
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.
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.wikipedia.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/4khv28q>, 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.
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.
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.
For completeness, a brief introduction to Turing machines is presented in 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).
a. AEM firing patterns are randomly generated that are Turing incomputable to determine their computational purpose.
b. AEM representations can be 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 firing patterns, 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].
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, such as input from a user, such from a keyboard, mouse (or other pointing device), microphone, or touchpad.
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 K={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, 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<l).
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 M(J, E, D), consists of a collection of input active elements, denoted as J={Ei: i∈Γ}; a collection of computational active elements E={Ei: i∈Ω}; and a collection of output active elements D={Ei: i∈Δ}.
Each computational and output active element, Ei, has the following components and properties.
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 M(J, E, D) 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 Ei.
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 Ei 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 k∈Γ∪Λ. 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), Ξki(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
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.
These rules represent the extended integers, addition and subtraction.
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.
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.
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.
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.
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.
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.
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
Once command (Element (Time clock) (Name clock) (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.
To understand the behavior of the Meta command, consider the execution of
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.
Command C is executed 6 times with arguments clock, 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 patterns, machine computation and interpretation are defined.
Firing Pattern
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 F(Ei, W)=[s1, . . . , sn]={s∈W: gi(s)=1} is called a firing sequence of the active element Ei over the window of time W. From active elements {E1, E2, . . . , En} create the tuple (F(E1, W), F(E2, W), . . . , F(En, W)) which is called a firing pattern of the active elements {E1, E2, . . . , En} within the window of time W.
At the machine level of interpretation, firing patterns (firing representations) express the input to, the computation of, and the output of an active element machine. At a more abstract level, firing patterns 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 Patterns.
Let W1, . . . , Wn be a sequence of time intervals. Let F(E, W1)=(F(E1, W1), F(E2, W1), . . . , F(En, W1)) be a firing pattern of active elements E={E1, . . . , En} over the interval W1. In general, let F(E, Wk)=(F(E1, Wk), F(E2, Wk), . . . F(En, Wk)) be a firing pattern over the interval of time Wk. From these, a sequence of firing patterns, [F(E, W1), F(E, W2), . . . , F(E, Wn)] is created.
Machine Computation
Let [F(E, W1), F(E, W2), . . . , F(E, Wn)] be a sequence of firing patterns. [F(E, S1), F(E, S2), . . . , F(E, Sm)] is some other sequence of firing patterns. Suppose machine architecture M(I, E, O) has input active elements I fire with the pattern [F(E, S1), F(E, S2), . . . , F(E, Sm)] and consequently M's output active elements O fire according to [F(E, W1), F(E, W2), . . . , F(E, Wn)]. In this case, the machine M computes [F(E, W1), F(E, W2), . . . , F(E, Wn)] from [F(E, S1), F(E, S2), . . . , F(E, Sm)].
An active element machine is an interpretation between two sequences of firing patterns if the machine computes the output sequence of firing patterns from the input sequence of firing patterns.
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.
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.
In the general case, for n connection commands
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.
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 K1 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.
2. Fire element R_24 if edge {j, k} is red.
3. The following Meta commands cause these elements to keep firing after they have fired once.
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.
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.
6. For each vertex set {i, j, k} in T, the following elements are created.
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_ijk only fires when all three elements B_ij, B_jk, B_ik 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
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}}. For each 2-coloring of E, each edge is colored red or blue. There are 2|E| 2-colorings of E. For this graph,
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 DNA 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
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 yjzk 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=i.
First, two useful program commands are defined.
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.
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.
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.
Element S01 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.
The commands
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
Element P12 fires at time 5 because of the commands
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
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,
Non-Deterministic Process and Quantum Random Hardware
Herein the term “process” refers to and expresses a broader notion than “algorithm”. The formal notion of “Turing machine” and of “algorithm” was presented in Turing's paper[32] and refers to a finite machine that executes a finite number of instructions with finite memory. “Algorithm” is a deterministic process in the following sense: if the finite machine is completely known and the input to the machine is known, then the future behavior of the machine can be determined. There are quantum processes and other embodiments that measure quantum effects from photons (or other physically non-deterministic processes). One embodiment is shown in
Some examples of physically non-deterministic processes are as follows. In some embodiments that utilize non-determinism, a semitransparent mirror may be used where photons that hit the mirror may take two or more paths in space. In one embodiment, if the photon is reflected then it takes on one bit value b that is a 0 or a 1; if the photon is transmitted, then it takes on the other bit value 1−b. In another embodiment, the spin of an electron may be sampled to generate the next non-deterministic bit.
In still another embodiment, a protein, composed of amino acids, spanning a cell membrane or artificial membrane, that has two or more conformations can be used to detect non-determinism: the protein conformation sampled may be used to generate a non-deterministic value in {0, . . . n−1} where the protein has n distinct conformations. In an alternative embodiment, one or more rhodopsin proteins could be used to detect the arrival times of photons and the differences of arrival times could generate non-deterministic bits. In some embodiments, a Geiger counter may be used to sample non-determinism. Lastly, any one of procedures in this specification may use random events such as a quantum event (non-deterministic process). In some embodiments, these quantum events can be emitted by the light emitting diode (LED) device, shown in
In an embodiment, a transducer measures the quantum effects from the emission and detection of photons, wherein the randomness is created by the non-deterministic process of photon emission and photon detection. The recognition of non-determinism observed by quantum random number generators and other quantum embodiments is based on experimental evidence and years of statistical testing. Furthermore, the quantum theory—derived from the Kochen-Specker theorem and its extensions [4, 5]—implies that the outcome of a quantum measurement cannot be known in advance and cannot be generated by a Turing machine (digital computer program). As a consequence, a physically non-deterministic process cannot be generated by an algorithm: namely, a sequence of operations executed by a digital computer program.
AEM Firing Patterns Execute a Digital Computer Program
In some embodiments, an AEM using randomness executes a universal Turing machine (digital computer program) or a von Neumann machine. In an embodiments, the randomness is generated from a non-deterministic physical process. In some embodiments, the randomness is generated using quantum events such as the emission and detection of photons. 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 non-deterministic 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 events in a semiconductor material or other physical phenomena. In some embodiments, the randomness is generated by a light emitting diode (
Procedure 1. Randomness generates an AEM, representing a real number in the interval [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 non-deterministic process is physically contained in the active element machine. In other embodiments, the emission part of the random process is separate from 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 lying in the interval [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)
Suppose a sequence of random bits—obtained from the environment or from a non-deterministic 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.
The execution of (C (Args 0)) causes three connection commands to execute.
Because of the first connection command
Thus b1=0. At time 2, input element I fires, so the following commands are executed.
The execution of (C (Args 2)) causes the three connection commands to execute.
Because of the first connection command
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
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
, xor ⊕, 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
Observe that |(X, W)|=0 for firing pattern 0000 shown in
The element command for P is:
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.
If Xk is not supposed to fire during W, then the following connection is established.
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.
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)
(
A v
B). 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.
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.
Below are the connection commands for making P fire if and only if firing pattern 0010 occurs during W.
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
Similarly,
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 Xj, 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=(A
B) is to be computed with the firing pattern 0101. Observe that ƒ13−1{1}={(1, 0), (0, 1), (0, 0)}. Thus, the separation rules
for k in {0, 2} work because X0 and X2 fire if and only if A fires and B fires. Similarly,
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.
The five commands make element P fire if and only if firing pattern 0101 occurs.
Case 1: (0
0). 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
Therefore, (0
0)=1 is computed.
Case 2: (1
0). 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
(1
0)=1 is computed.
Case 3: (0
1). 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
(0
1)=1 is computed.
Case 4: (1
1). 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
(1
1)=0 is computed.
Overall, any one of the sixteen boolean functions in
Executing a Digital Computer with Random Firing Patterns
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.
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 of the universal Turing machine and the elements in {0, 1}2 as follows: 000, 1
01, y
10 and A
11. Furthermore, consider the following correspondence of the states with the elements of {0, 1}3: q1
001, q2
010, q3
011, q4
100, q5
101, q6
110, q7
111 and the halting state h
000. Further consider L
0 and R
1 in {0, 1}. An active element machine is designed to compute the universal Turing Machine program η shown in
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
η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}={(111, 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)}
η3−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)}
η−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)}
η−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.
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
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.
For D0, follow the first row of separation
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.
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 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.
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 and the meta commands set the threshold P3 to −2(14−k)+1 where k is 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).
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.
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
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 (memory address k of the digital computer) where k is an integer.
A marker active element locates the leftmost tape square (lowest memory address used by the digital computer) and a separate marker active element
locates the rightmost tape square (highest memory address used by the digital computer). 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 (one memory cell lower in the digital computer) 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 (one memory cell higher in the digital computer) and the machine (digital computer) is reading a 0.
There are a collection of elements that represent the tape contents (memory contents) of the UTM (digital computer). 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 (memory cell k). For example, if elements (S 5) and (T 5) are not firing, then tape square 5 (memory cell 5 of the digital computer) contains alphabet symbol 0. If element (S−7) is firing and element (T−7) is not firing, then tape square −7 (memory cell −7) contains alphabet symbol 1. If element (S 13) is firing and element (T 13) is firing, then tape square 13 (memory cell 13 of the digital computer) 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 (memory contents) of the UTM (digital computer), 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 Universal Turing machine (digital computer). The following active element machine program enables a new alphabet symbol to be copied to the tape (memory of the digital computer).
the following program enables a new state to be copied.
The sequence of steps by which the UTM (digital computer) is executed with an AEM are described.
1. Tape contents (memory contents) are initialized and the marker elements L and R are initialized.
2. The tape head (location of the next instruction in memory) 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 ain and the current state (q 0), (q 1), (q 2) is copied to qin.
4. η(qin, 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 (where the digital computer stopped executing its computer program).
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 (memory cell) 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 L. If so, then have L 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 (location of the next instruction in memory) has moved to the right of the tape square marked by R. If so, then have R 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.
In reference [5], it was shown that quantum randomness is Turing incomputable (digital computer 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 active elements {D0, D1, D13} computing η3; the firing pattern of active elements {E0, E1, . . . E12} computing η4; and the firing pattern of active 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 (digital computer program) that can map these firing patterns back to the sequence of instructions executed by the universal Turing machine (universal digital computer). In summary, these methods demonstrate a new class of computing machines and a new type of computational procedure where the purpose of the program's execution is incomprehensible (Turing incomputable) to malware.
Turing Machine and Affine Map Correspondence
DEFINITION 2.1 Turing Machine
A Turing machine is a triple (Q, A, η) where
The η function acts as the program for the Turing machine in the following manner. For each q in Q and α in A, the expression η(q, α)=(r, β, x) describes how machine (Q, A, η) executes one computational step. When in state q and scanning alphabet symbol α on the tape:
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 C=(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 C 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 N={(q, k, T)∈C: 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
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
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.
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:
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), (q1, k1, T1), . . . , (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 η: N→C 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)].
The machine execution steps are shown in 1
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
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
y(q, k, T)=q Tk−1·Tk−2 Tk−3 Tk−4 . . . where this decimal sequence in base B represents a real number as
Define function φ: C→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 C. Let C′denote the set of equivalence classes [(q, k, T)] on C. 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.
(ρ, C′) is a metric space where ρ is induced via φ by the Euclidean metric in P.
Consider points p1, p2 in P with p1=(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)}
Let u=[(q, k, S)], w=[(r, l, T)] be elements of C′. Define ρ: C′×C′→R as ρ(u, w)=d(φ(u), φ(w))=√{square root over ([x(q,k,S)−x(r,l,T)]2+[y(q,k,S)−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 C′.
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
DEFINITION 2.16 Left Affine Function
This is for case I. where η(q, Tk)=(r, β, L). See
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.
yr Tk−2·Tk−3Tk−4Tk−5 . . .
By=q Tk−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
m=Bv(Tk−1)+v(β)−v(Tk) and n=Bv(r)−B2 v(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−1 b·Tk+1 Tk+2 . . .
The x coordinate of
y(r,k−1,Tb)=rTk−2·Tk−3Tk−4 . . .
The y coordinate of
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 |−B2 v(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
xTk+1Tk+2·Tk+3Tk+4 . . .
Bx=TkTk+1Tk+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
where m=−B2 v(Tk) and n=B v(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
From η(q, Tk)=(r, b, R), it follows that y(r, k+1, Tb)=rb. Tk−1 Tk−2 Tk−3 . . .
The y coordinate of
REMARK 2.21 Minimum Vertical Translation for Right Affine Function
First,
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.
on domain U(0, 0) and
on U(4, 0)
(0, 0) is a fixed point of gƒ. The orbit of any 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 ƒ1 (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,
Also,
There is a 1 to 1 correspondence between the mth point of the orbit
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
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
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
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=ƒS(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
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
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:
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+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.
where the head of E is u+t−s. Observe that |E|=m+1
Case B.) u>s and m−u≤n−s. See
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
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
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.
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)=(q2, b1) where η 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) (q2, 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
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 q1 is the only state visited twice, then the proof is completed. Otherwise, define μ=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 w1 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, bn+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=W(t2). And V1(s1)=b1=Thus, V1 restricted to the window of execution I2 equals W 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.
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:
A prime directed edge is denoted as ΔΓ or [q, v0 v1 . . . vn, s]
[r, w0 w1 . . . wn, 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, a1) . . .
(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.
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
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.
((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
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
METHOD 4.12 Directed Partition Method
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
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))
(q(k+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) t) 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 . . . vn 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=vt 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.
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).
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 P={Δ1Γ1, . . . , Δk
Γk, . . . , ΔN
ΓN} 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.
LEMMA 4.25 Overlap Matching Prime Head Nodes are Equal
If Δj=[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. Δj 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, Δ1 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 v1 . . . vn, 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, F1), 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, . . . , ΔN
ΓN} 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(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
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.
(qj+1, aj+1)
...
(qj+k, aj+k) equals
(qj+k+2,
...
(qj+2k+1, aj+2k+1)
(qj+1, aj+1)
...
(qj+k,
...
(qj+2k+1, aj+2k+1)
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
a
0
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 Δ=[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
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.
Γj in P
Γj link matches with IIp(k) then
REMARK 4.37|Φ(k)| is finite and |Φ(k)|≤|P|k
PROOF. |Φ(1)|=|P|. Analyzing the nested loops, in method 4.36
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.
Each embodiment disclosed herein may be used or otherwise combined with any of the other embodiments disclosed. Any element of any embodiment may be used in any embodiment.
Although the invention has been described with reference to specific embodiments, it will be understood by those skilled in the art that various changes may be made and equivalents may be substituted for elements thereof without departing from the true spirit and scope of the invention. In addition, modifications may be made without departing from the essential teachings of the invention.
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 incorporatedherein 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; this application is a continuation-in-part of U.S. Non-provisional patent application Ser. No. 13/373,948, entitled “Secure active element machine”, filed Dec. 6, 2011, which is incorporated herein by reference; this application is a related to European application EP 12 742 528.8, entitled “SECURE ACTIVE ELEMENT MACHINE”, filed Jan. 31, 2012, which is incorporated herein by reference.
| Number | Name | Date | Kind |
|---|---|---|---|
| 3950733 | Cooper et al. | Apr 1976 | A |
| 4255811 | Adler | Mar 1981 | A |
| 4316055 | Feistel | Feb 1982 | A |
| 4405829 | Rivest et al. | Sep 1983 | A |
| 4555796 | Sakoe | Nov 1985 | A |
| 4660166 | Hopfield | Apr 1987 | A |
| 4697242 | Holland et al. | Sep 1987 | A |
| 4734856 | Davis | Mar 1988 | A |
| 4881178 | Holland et al. | Nov 1989 | A |
| 4961005 | Salam | Oct 1990 | A |
| 4962342 | Mead et al. | Oct 1990 | A |
| 5001753 | Davio et al. | Mar 1991 | A |
| 5148514 | Arima et al. | Sep 1992 | A |
| 5155802 | Mueller et al. | Oct 1992 | A |
| 5212821 | Gorin et al. | May 1993 | A |
| 5216752 | Tam | Jun 1993 | A |
| 5297207 | Degele | Mar 1994 | A |
| 5303328 | Masui et al. | Apr 1994 | A |
| 5325464 | Pechanek et al. | Jun 1994 | A |
| 5343554 | Koza et al. | Aug 1994 | A |
| 5369731 | Masumoto et al. | Nov 1994 | A |
| 5375170 | Shamir | Dec 1994 | A |
| 5390282 | Koza et al. | Feb 1995 | A |
| 5400436 | Nara et al. | Mar 1995 | A |
| 5422983 | Castelaz et al. | Jun 1995 | A |
| 5434987 | Abramson et al. | Jul 1995 | A |
| 5479570 | Imagawa et al. | Dec 1995 | A |
| 5481644 | Inazumi | Jan 1996 | A |
| 5504884 | Kyuma et al. | Apr 1996 | A |
| 5511123 | Adams | Apr 1996 | A |
| 5524175 | Sato et al. | Jun 1996 | A |
| 5524176 | Narita et al. | Jun 1996 | A |
| 5526317 | McClure | Jun 1996 | A |
| 5555281 | Williamson et al. | Sep 1996 | A |
| 5577167 | Brown | Nov 1996 | A |
| 5604801 | Dolan et al. | Feb 1997 | A |
| 5619618 | Bigus | Apr 1997 | A |
| 5623548 | Akiyama et al. | Apr 1997 | A |
| 5675710 | Lewis | Oct 1997 | A |
| 5687238 | Shimada | Nov 1997 | A |
| 5724428 | Rivest | Mar 1998 | A |
| 5737300 | Ota et al. | Apr 1998 | A |
| 5742738 | Koza et al. | Apr 1998 | A |
| 5768382 | Schneier et al. | Jun 1998 | A |
| 5787300 | Wijaya | Jul 1998 | A |
| 5802199 | Pare, Jr. et al. | Sep 1998 | A |
| 5818963 | Murdock et al. | Oct 1998 | A |
| 5819247 | Freund et al. | Oct 1998 | A |
| 5825880 | Sudia et al. | Oct 1998 | A |
| 5832466 | Feldgajer | Nov 1998 | A |
| 5835600 | Rivest | Nov 1998 | A |
| 5848403 | Gabriner et al. | Dec 1998 | A |
| 5867397 | Koza et al. | Feb 1999 | A |
| 5930780 | Hughes et al. | Jul 1999 | A |
| 5940825 | Castelli et al. | Aug 1999 | A |
| 5946673 | Francone et al. | Aug 1999 | A |
| 5946674 | Nordin et al. | Aug 1999 | A |
| 5946675 | Sutton | Aug 1999 | A |
| 6031911 | Adams et al. | Feb 2000 | A |
| 6041410 | Hsu et al. | Mar 2000 | A |
| 6049793 | Tomita | Apr 2000 | A |
| 6064880 | Alanara | May 2000 | A |
| 6067539 | Cohen | May 2000 | A |
| 6081766 | Chapman et al. | Jun 2000 | A |
| 6098059 | Nordin | Aug 2000 | A |
| 6105131 | Carroll | Aug 2000 | A |
| 6112187 | Fukawa | Aug 2000 | A |
| 6128607 | Nordin et al. | Oct 2000 | A |
| 6144293 | Plaschko et al. | Nov 2000 | A |
| 6169771 | Shou et al. | Jan 2001 | B1 |
| 6256619 | Grichnik | Jul 2001 | B1 |
| 6260031 | Schaffer et al. | Jul 2001 | B1 |
| 6275611 | Parthasarathy | Aug 2001 | B1 |
| 6286000 | Apte et al. | Sep 2001 | B1 |
| 6289353 | Hazlehurst et al. | Sep 2001 | B1 |
| 6292586 | Kawakami et al. | Sep 2001 | B1 |
| 6307956 | Black | Oct 2001 | B1 |
| 6311270 | Challener et al. | Oct 2001 | B1 |
| 6327661 | Kocher et al. | Dec 2001 | B1 |
| 6332137 | Hori et al. | Dec 2001 | B1 |
| 6341372 | Datig | Jan 2002 | B1 |
| 6347143 | Goff et al. | Feb 2002 | B1 |
| 6418434 | Johnson et al. | Jul 2002 | B1 |
| 6424980 | Iizuka et al. | Jul 2002 | B1 |
| 6424997 | Buskirk, Jr. et al. | Jul 2002 | B1 |
| 6470261 | Ng et al. | Oct 2002 | B1 |
| 6493686 | Francone et al. | Dec 2002 | B1 |
| 6502081 | Wiltshire, Jr. et al. | Dec 2002 | B1 |
| 6513025 | Rosen | Jan 2003 | B1 |
| 6523016 | Michalski | Feb 2003 | B1 |
| 6532305 | Hammen | Mar 2003 | B1 |
| 6601053 | Schaffer et al. | Jul 2003 | B1 |
| 6607136 | Atsmon et al. | Aug 2003 | B1 |
| 6636973 | Novoa et al. | Oct 2003 | B1 |
| 6651049 | Agrawal et al. | Nov 2003 | B1 |
| 6678548 | Echauz et al. | Jan 2004 | B1 |
| 6704757 | Ohmi et al. | Mar 2004 | B1 |
| 6748588 | Fraser et al. | Jun 2004 | B1 |
| 6751601 | Zegers | Jun 2004 | B2 |
| 6751621 | Calistri-Yeh et al. | Jun 2004 | B1 |
| 6754645 | Shi et al. | Jun 2004 | B2 |
| 6782120 | Mödl et al. | Aug 2004 | B2 |
| 6810118 | Martin | Oct 2004 | B1 |
| 6853988 | Dickinson et al. | Feb 2005 | B1 |
| 6868525 | Szabo | Mar 2005 | B1 |
| 6879689 | Carroll et al. | Apr 2005 | B2 |
| 6928368 | Bulla, Jr. et al. | Aug 2005 | B1 |
| 6934938 | May et al. | Aug 2005 | B2 |
| 6950696 | Björling et al. | Sep 2005 | B2 |
| 6965907 | Klass | Nov 2005 | B2 |
| 6971008 | Wasilewski et al. | Nov 2005 | B2 |
| 6990487 | Akaboshi et al. | Jan 2006 | B2 |
| 6993658 | Engberg et al. | Jan 2006 | B1 |
| 7047426 | Andrews et al. | May 2006 | B1 |
| 7066382 | Kaplan | Jun 2006 | B2 |
| 7103772 | Jørgensen et al. | Sep 2006 | B2 |
| 7162032 | Brekne | Jan 2007 | B2 |
| 7200220 | Yamao | Apr 2007 | B1 |
| 7215769 | Fiske | May 2007 | B2 |
| 7222238 | Bleumer et al. | May 2007 | B2 |
| 7249116 | Fiske | Jul 2007 | B2 |
| 7308708 | Blume | Dec 2007 | B2 |
| 7317799 | Hammersmith et al. | Jan 2008 | B2 |
| 7319987 | Hoffman et al. | Jan 2008 | B1 |
| 7353541 | Ishibashi et al. | Apr 2008 | B1 |
| 7360028 | Tremblay | Apr 2008 | B1 |
| 7398260 | Fiske | Jul 2008 | B2 |
| 7415614 | Guillou | Aug 2008 | B2 |
| 7565548 | Fiske et al. | Jul 2009 | B2 |
| 7603565 | Baird, III et al. | Oct 2009 | B2 |
| 7623468 | Panigrahy et al. | Nov 2009 | B2 |
| 7657033 | Fiske | Feb 2010 | B2 |
| 7669236 | Fiske | Feb 2010 | B2 |
| 7702911 | Fiske | Apr 2010 | B2 |
| 7707622 | Fiske | Apr 2010 | B2 |
| 7770018 | Fiske | Aug 2010 | B2 |
| 7886155 | Fiske | Feb 2011 | B2 |
| 7979716 | Fiske | Jul 2011 | B2 |
| 8010467 | Fiske | Aug 2011 | B2 |
| 8019705 | Fiske | Sep 2011 | B2 |
| 8077933 | Fiske | Dec 2011 | B1 |
| 8127141 | Hyppönen | Feb 2012 | B2 |
| 8190682 | Paterson-Jones et al. | May 2012 | B2 |
| 8209751 | Fiske | Jun 2012 | B2 |
| 8712942 | Fiske | Apr 2014 | B2 |
| 8817981 | Fiske | Aug 2014 | B2 |
| 8850574 | Ansel et al. | Sep 2014 | B1 |
| 9026768 | Fiske | May 2015 | B2 |
| 9032537 | Fiske | May 2015 | B2 |
| 9235697 | Fiske | Jan 2016 | B2 |
| 20010045451 | Tan et al. | Nov 2001 | A1 |
| 20020038294 | Matsugu | Mar 2002 | A1 |
| 20020046147 | Livesay | Apr 2002 | A1 |
| 20020059154 | Rodvold | May 2002 | A1 |
| 20020124176 | Epstein | Sep 2002 | A1 |
| 20020172366 | Peterka et al. | Nov 2002 | A1 |
| 20020176580 | Horiuchi et al. | Nov 2002 | A1 |
| 20030028757 | May et al. | Feb 2003 | A1 |
| 20030046589 | Gregg | Mar 2003 | A1 |
| 20030093416 | Akaboshi et al. | May 2003 | A1 |
| 20030131031 | Klass | Jul 2003 | A1 |
| 20030147532 | Hakkarainen et al. | Aug 2003 | A1 |
| 20030183878 | Tajiri et al. | Oct 2003 | A1 |
| 20030208697 | Gardner | Nov 2003 | A1 |
| 20030212645 | Schaffer et al. | Nov 2003 | A1 |
| 20030236761 | Fiske | Dec 2003 | A1 |
| 20040010720 | Singh et al. | Jan 2004 | A1 |
| 20040107170 | Labrou et al. | Jun 2004 | A1 |
| 20040117636 | Cheng | Jun 2004 | A1 |
| 20040128004 | Adams et al. | Jul 2004 | A1 |
| 20040162795 | Dougherty et al. | Aug 2004 | A1 |
| 20040199775 | Ser et al. | Oct 2004 | A1 |
| 20040215708 | Higashi | Oct 2004 | A1 |
| 20040228480 | Fiske | Nov 2004 | A1 |
| 20040236694 | Tattan et al. | Nov 2004 | A1 |
| 20040267387 | Samadani | Dec 2004 | A1 |
| 20050005157 | Folmsbee | Jan 2005 | A1 |
| 20050044044 | Burger et al. | Feb 2005 | A1 |
| 20050044425 | Hypponen | Feb 2005 | A1 |
| 20050071720 | Dattaram Kadkade | Mar 2005 | A1 |
| 20050075702 | Shafer | Apr 2005 | A1 |
| 20050081016 | Sakai et al. | Apr 2005 | A1 |
| 20050103351 | Stomberg et al. | May 2005 | A1 |
| 20050117596 | Kopetz | Jun 2005 | A1 |
| 20050193198 | Livowsky | Sep 2005 | A1 |
| 20050210267 | Sugano et al. | Sep 2005 | A1 |
| 20060107040 | Fiske | May 2006 | A1 |
| 20060107041 | Fiske | May 2006 | A1 |
| 20060107064 | Fiske | May 2006 | A1 |
| 20060107067 | Safal et al. | May 2006 | A1 |
| 20060107068 | Fiske | May 2006 | A1 |
| 20060107309 | Fiske | May 2006 | A1 |
| 20060107315 | Fiske | May 2006 | A1 |
| 20060117188 | Fiske et al. | Jun 2006 | A1 |
| 20060129811 | Fiske | Jun 2006 | A1 |
| 20060230284 | Fiske | Oct 2006 | A1 |
| 20060236226 | Meijer et al. | Oct 2006 | A1 |
| 20060245225 | Vorbach | Nov 2006 | A1 |
| 20060259894 | Fiske | Nov 2006 | A1 |
| 20060277533 | Fiske | Dec 2006 | A1 |
| 20070014394 | Harder et al. | Jan 2007 | A1 |
| 20070061777 | Vashi et al. | Mar 2007 | A1 |
| 20070079108 | Fiske | Apr 2007 | A1 |
| 20070118754 | Togashi et al. | May 2007 | A1 |
| 20070240160 | Paterson-Jones et al. | Oct 2007 | A1 |
| 20070255963 | Pizano et al. | Nov 2007 | A1 |
| 20070258595 | Choy | Nov 2007 | A1 |
| 20070281664 | Kaneko et al. | Dec 2007 | A1 |
| 20070288668 | Fiske | Dec 2007 | A1 |
| 20070297610 | Chen et al. | Dec 2007 | A1 |
| 20080106605 | Schrijen et al. | May 2008 | A1 |
| 20080288786 | Fiske | Nov 2008 | A1 |
| 20080294899 | Gazzetta et al. | Nov 2008 | A1 |
| 20090013402 | Plesman | Jan 2009 | A1 |
| 20090025090 | Clement et al. | Jan 2009 | A1 |
| 20090055458 | O'Neil | Feb 2009 | A1 |
| 20090158049 | Fiske | Jun 2009 | A1 |
| 20090178115 | Fiske | Jul 2009 | A1 |
| 20090228714 | Fiske et al. | Sep 2009 | A1 |
| 20090292920 | Willey | Nov 2009 | A1 |
| 20100011222 | Fiske | Jan 2010 | A1 |
| 20100046755 | Fiske | Feb 2010 | A1 |
| 20100257544 | Kleban | Oct 2010 | A1 |
| 20110030053 | Lin et al. | Feb 2011 | A1 |
| 20110066833 | Fiske | Mar 2011 | A1 |
| 20110213979 | Wiseman et al. | Sep 2011 | A1 |
| 20110274273 | Fiske | Nov 2011 | A1 |
| 20120047563 | Wheeler | Feb 2012 | A1 |
| 20120096434 | Rama | Apr 2012 | A1 |
| 20120177201 | Ayling et al. | Jul 2012 | A1 |
| 20120198560 | Fiske | Aug 2012 | A1 |
| 20120311320 | Brown et al. | Dec 2012 | A1 |
| 20130042111 | Fiske | Feb 2013 | A1 |
| 20140137188 | Bartholomay | May 2014 | A1 |
| 20140201536 | Fiske | Jul 2014 | A1 |
| 20150261541 | Fiske | Sep 2015 | A1 |
| Number | Date | Country |
|---|---|---|
| 1909080 | Apr 2008 | EP |
| 2944321 | Sep 1999 | JP |
| 2009-3501 | Jan 2009 | JP |
| WO 2004027704 | Apr 2004 | WO |
| WO 2006055767 | May 2006 | WO |
| WO 2006069082 | Jun 2006 | WO |
| WO 2006091301 | Aug 2006 | WO |
| WO 2007008519 | Jan 2007 | WO |
| WO 2007075156 | Jul 2007 | WO |
| WO 2008053279 | May 2008 | WO |
| WO 2012097362 | Jul 2012 | WO |
| WO 2012106383 | Aug 2012 | WO |
| WO 2013044192 | Mar 2013 | WO |
| WO 2015023550 | Feb 2015 | WO |
| Entry |
|---|
| Jennewein et al., Quantum Cryptography with Entangled Photons, Physical Review Letters vol. 84, No. 20, pp. 4729-4732, May 15, 2000. |
| Author: Weiss, Kenneth P.; Title: “When a Password Is Not a Password”; Pub. Date: Oct. 1990; pp. 100-108. Found on the World Wide Web at: http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=111393;IEEE 1990 International Carnahan Conference on Security Technology. |
| Author: Elboukhari, Mohamed, et al.; Title: “Implementation of Secure Key Distribution based on Quantum Cryptography”; Pub. Date: 2009; pp. 1-5; IEEE. |
| Author: Gurney, Kevin; Title: “An Introduction to Neural Networks”; Pub. Date: 1997; pp. 1-232; Publisher: CRC Press, U.S.A. |
| Author: Upegui, Andrés, et al.; Title: “A methodology for evolving spiking neural-network topologies on line using partial dynamic reconfiguration”; pp. 1-8; Swiss Federal Institute of Technology, Logic Systems Laboratory, 1015 Lausanne, Switzerland. |
| Author: Heistermann, Jochen; Title: “Learning in Neural Nets by Genetic Algorithms”, Pub. Date: 1990; pp. 165-168; Publisher: Elsevier Science Publishers B.V., North-Holland, XP000135699. |
| Author: Bremermann, H.J.; Title: “Optimization Though Evolution and Recombination”, Pub. Date: 1962; pp. 93-106; Publisher: Spartan Books, Washington D.C.; Self-Organizing Systems. |
| Author: Rall, Wilfrid; Title: “Theoretical Significance of Dendritic Trees for Neuronal Input-Output Relations”, Pub. Date: 1964; pp. 122-145; Neural Theory and Modeling, ed., R. F. Reiss; Palo Alto: Stanford University Press. |
| Author: Turing, Alan; Title: “On Computable Number with an Application to the Entscheidungs Problem”, Pub. Date: 1936; pp. 230-265, 544-546; vol. 93; Proceedings London Mathematical Society, England. |
| Author: Garis, Hugo De, et al.; Title: “The Cam-Brain Machine (CBM): an FPGA Based Hardware Tool that Evolves a 1000 Neuron—Net Circuit Module in Seconds and Updates a 75 Million Neuron Artificial Brain for Real-Time Robot Control”, Pub. Date: 2002, Neural Computing. |
| Author: Atsumi, Masayasu; Title: “Artificial Neural Development for Pulsed Neural Network Design—A Simulation Experiment on Animat's Cognitive Map Genesis”; Pub. Date: 2002, pp. 188-198; Combinations of Evolutionary Computation and Neural Networks, IEEE. |
| Author: Siegelmann, Hava T. et al.; Title: “Neural Networks and Analog Computation Beyond the Turing Limit”; Pub. Date: 1999; pp. 29-33, 153-164; Birkhäuser. |
| Author: Herault, Laurent; Title: “Optimization by Pulsed Recursive Neural Networks”; Pub. Date: 1995, pp. 1678-1683; Publisher: IEEE. |
| Author: Lindgren, Kristian, et al.; Title: “Regular Language Inference Using Evolving Neural Networks”; Pub. Date: 1992, pp. 1-12; Publisher: IEEE. |
| Author: Schaffer, David J., et al.; Title: “Combinations of Genetic Algorithms and Neural Networks: A Survey of the State of the Art”; Pub. Date: 1992, Publisher: IEEE. |
| Author: Mead, Carver; Title: “Analog VLSI and Neural Systems”; Pub. Date: 1989; pp. 36-39, 67-81, 208-209, 260-263; Publisher: Addison-Wesley, United States. |
| Author: Bledsoe, W.W.; Title: “The Use of Biological Concepts in the Analytical Study of Systems”; Pub. Date: 1961; pp. 1-25; Panoramic Research Incorporated, Palo Alto; ORSA TIMS National Meeting; San Francisco, CA. |
| Author: Friedman, George J.; Title: “Digital Simulation of an Evolutionary Process”; Pub. Date: 1959, pp. 171-184, vol. 4 of General Systems Yearbook. |
| Author: Box, George E.P.; Title: “Evolutionary Operation: A Method for Increasing Industrial Production”, Pub. Date: 1957; pp. 81-101; vol. 6, No. 2, Royal Statistical Society, England, Applied Statistics. |
| Author: Schneider, Michael G., Gersting, Judith L., Title: “CSC 150 chapter 11: Models of Computation”, Pub. Date: 2007; pp. 1-6; Turing Machines and State transition diagrams, Third Edition, Course Technology. |
| Author: Angeline, Peter J. et al.; Title: “An Evolutionary Algorithm that Constructs Recurrent Neural Networks”; Pub. Date: Jan. 1994; pp. 54-65; IEEE Transactions on Neural Networks, vol. 5, No. 1. |
| Author: Azam, Farooq; Title: “Biologically Inspired Modular Neural Networks”; Pub. Date: May 2000; pp. 1-149; Virginia Tech. |
| Author: Dasgupta, Dipankar, et al.; Title: “Designing Application-Specific Neural Networks using the Structured Genetic Algorithm”; Pub. Date: Jun. 6, 1992; pp. 1-11; IEEE Computer Society Press. |
| Author: Elias, John G.; Title: “Genetic Generation of Connection Patterns for a Dynamic Artificial Neural Network”; Pub. Date: 1992; pp. 1-17; Proceedings of the Combinations of Genetic Algorithms and Neural Networks Workshop, Cogan, IEEE. |
| Author: Floreano, Dario, et al.; Title: “Evolution of Spiking Neural Controllers for Autonomous Vision-Based Robots”; Pub. Date: 2001; pp. 38-61; T. Gomi (Ed.): ER 2001, LCNS 2217; Springer-Verlag Berlin Heidelberg 2001. |
| Author: Gallagher, John C., et al.; Title: “Continuous Time Recurrent Neural Networks: A Paradigm for Evolvable Analog Controller Circuits”; Pub. Date: 2000; pp. 1-6. |
| Author: Kanamaru, Takashi, et al.; Title: “Stochastic resonance in a pulse neural network with a propagational time delay”; Pub. Date: 2000; pp. 101-107; BioSystems 58. |
| Author: Marian, Ioana Domnica; Title: “A biologically inspired model of motor control of direction”; Pub. Date: Oct. 2002; pp. 1-209; MS Thesis, University College, Dublin, Ireland. |
| Author: Murray, Alan F, et al.; Title: “Pulse-Stream VLSI Neural Networks Mixing Analog and Digital Techniques.”; Pub. Date: Mar. 1991, pp. 193-204; IEEE Transactions on Neural Networks, vol. 2, No. 2. |
| Author: Reyneri, L.M.; Title: “Theoretical and Implementation Aspects of Pulse Streams: an Overview”; Pub. Date: 1999; pp. 1-12. |
| Author: Yao, Xin; Title: “Evolving Artificial Neural Networks.”; Pub. Date: Sep. 1999; pp. 1423-1447; vol. 87, No. 9, Proceedings of the IEEE. |
| Author: Fiske, Michael Stephen; Title: “Turing Incomputable Computation”; pp. 66-91; A. Voronkov (ed.), Turing-100 (EPiC Series, vol. 10). |
| Author: Upegui, Andrés, et al.; Title: “An FPGA platform for on-line topology exploration of spiking neural networks”; Pub. Date: 2005; pp. 211-223; Microprocessors and Microsystems 29, Elsevier. |
| Author: Shaikh-Husin, Nasir , et al.; Title: “Pulse Coded Neural Network Implementation in VLSI”; Pub. Date: 2000; pp. 237-241; IEEE. |
| Supplementary European Search Report of European Patent Application No. EP05849368; search date: Jul. 15, 2009. |
| Supplementary European Search Report of European Patent Application No. EP05854862; search date: Jan. 11, 2010. |
| Supplemental Partial European Search Report of European Patent Application No. EP05858695; search date: Sep. 16, 2011. |
| Supplementary European Search Report of European Patent Application No. EP06748170; search date: Dec. 14, 2012. |
| Author: El-Masry, Ezz I., et al; Title: “Implementations of Artificial Neural Networks Using Current-Mode Pulse Width Modulation Technique”; Pub. Date: May 1997; pp. 532-548; IEEE Transactions on Neural Networks, vol. 8, No. 3. |
| Author: Millberg, Mikael, et al; Title: “Generic VHDL Implementation of a PCNN with Loadable Coefficients”; pp. 186-197; SPIE vol. 3728. |
| Author: Strey, Alfred; Title: “On the suitability of SIMD extensions for neural network simulation”; Pub. Date: 2003; pp. 341-351; Microprocessors and Microsystems, Elsevier Science B.V. , Department of Neural Information Processing, University of Ulm, D-89069, Ulm, Germany. |
| Author: Horio, Yoshihiko, et al., Title: “An asynchronous spiking chaotic neuron integrated circuit”, Pub. Date: Mar. 2005, pp. 447-472, Neurocomputing, vol. 64, Available online Dec. 7, 2004. |
| Author: Maniezzo, Vittorio, Title: “Genetic evolution of the topology and weight distribution of neural networks.”; Pub. Date: Jan. 1994, pp. 39-53; IEEE Transactions on Neural Networks, vol. 5, No. 1. |
| Number | Date | Country | |
|---|---|---|---|
| 20150186683 A1 | Jul 2015 | US |
| Number | Date | Country | |
|---|---|---|---|
| Parent | 13373948 | Dec 2011 | US |
| Child | 14643774 | US |
