Secure non-deterministic, self-modifiable computing machine

Abstract

Based upon the principles of randomness and self-modification a novel computing machine is constructed. This computing machine executes computations, so that it is difficult to apprehend by an adversary and hijack with malware. These methods can also be used to help thwart reverse engineering of proprietary algorithms, hardware design and other areas of intellectual property.

Description

FIELD

The specification generally relates to computing: computing hardware, machine-implemented methods, and machine-implemented systems.

BRIEF DESCRIPTION OF FIGURES AND TABLES

In the following figures, although they may depict various examples of the invention, the invention is not limited to the examples depicted in the figures.

FIG. 1 shows a fire pattern of 0000 for active elements X₀, X₁, X₂, and X₃. Elements X₀, X₁, X₂, and X₃ don't fire during window W.

FIG. 2 shows a fire pattern of 0001 for active elements X₀, X₁, X₂, and X₃. During window W, elements X₀, X₁, X₂ don't fire and X₃ fires.

FIG. 3 shows a fire pattern of 0010 for active elements X₀, X₁, X₂, and X₃. During window W, only element X₂ fires.

FIG. 4 shows a fire pattern of 0011 for active elements X₀, X₁, X₂, and X₃. During window W, only elements X₂ and X₃ fire.

FIG. 5 shows a fire pattern of 0100 for active elements X₀, X₁, X₂, and X₃. During window W, only element X₁ fires.

FIG. 6 shows a fire pattern of 0010 for active elements X₀, X₁, X₂, and X₃ used to compute 1⊕0.

FIG. 7 shows a fire pattern of 0010 for active elements X₀, X₁, X₂, and X₃ used to compute 0⊕1.

FIG. 8 shows a fire pattern of 1011 for active elements X₀, X₁, X₂, and X₃ used to compute 1⊕1.

FIG. 9 shows a fire pattern of 0100 for active elements X₀, X₁, X₂, and X₃ used to compute 0⊕0.

FIG. 10 shows a fire pattern of 0101 for active elements X₀, X₁, X₂, and X₃ used to compute ¬(0∧0)=1.

FIG. 11 shows a fire pattern of 0101 for active elements X₀, X₁, X₂, and X₃ used to compute ¬(1∧0)=1.

FIG. 12 shows a fire pattern of 0101 for active elements X₀, X₁, X₂, and X₃ used to compute ¬(0∧1)=1.

FIG. 13 shows a fire pattern of 1010 for active elements X₀, X₁, X₂, and X₃ used to compute ¬(1∧1)=0.

FIG. 14 shows a deterministic machine configuration (q, k, T) with the machine in state q, machine head at memory address k (memory address of the digital computer) and containing alphabet symbol T(k) in memory address k (memory cell k of the digital computer).

FIG. 15 shows the window of execution for one cycle of a periodic point p=[q, 121212222]

FIG. 16 shows the pertinent parts of the machine configuration used to determine the unit square domain of a left affine map (2.16) or right affine map (2.19).

FIG. 17 shows a deterministic machine computational step that corresponds to one iteration of a corresponding left affine function (2.16).

FIG. 18 shows a deterministic machine computational step that corresponds to one iteration of a right affine function (2.19).

FIG. 19 shows case A of the definition the Edge Pattern Substitution Operator.

FIG. 20 shows case B of the definition the Edge Pattern Substitution Operator.

FIG. 21 shows case C of the definition the Edge Pattern Substitution Operator.

FIG. 22 shows case D of the definition the Edge Pattern Substitution Operator.

FIG. 23 shows a diagram of an embodiment of a semiconductor chip that can detect photons and generates a non-deterministic process.

FIG. 24 shows a diagram of a semiconductor component of a light emitting diode that emits photons.

FIG. 25 shows a light emitting diode and some components.

FIG. 26 shows the level set rules for each boolean function ƒ: {0, 1}×{0, 1}→{0, 1}. The level set rules help design an active element machine program that separate elements of {(0, 0), (1, 0), (0, 1), (1, 1)}.

FIG. 27 shows Minsky's universal deterministic machine.

FIG. 28 shows the Boolean version of the universal deterministic machine in FIG. 27.

FIG. 29 shows the level set rules for η₀: the 0^th bit of deterministic program η in FIG. 28.

FIG. 30 shows the level set rules for η₁: the 1^st bit of deterministic program η in FIG. 28.

FIG. 31 shows the level set rules for η₂: the 2^nd bit of deterministic program η in FIG. 28.

FIG. 32 shows the level set rules for η₃: the 3^rd bit of deterministic program η in FIG. 28.

FIG. 33 shows the level set rules for η₄: the 4^th bit of deterministic program η in FIG. 28.

FIG. 34 shows the level set rules for η₅: the 5^th bit of deterministic program η in FIG. 28.

FIG. 35 shows all sixteen firing patterns of elements X₀, X₁, X₂, X₃ which represents four bits that are added using elements C₀, C₁, C₂, C₃ and elements P₀, P₁, P₂, P₃.

FIG. 36 shows the amplitudes from elements X₀, X₁, X₂, X₃ to elements C₀, C₁, C₂, C₃ and thresholds for elements C₀, C₁, C₂, C₃.

FIG. 37 shows the amplitudes from elements C₀, C₁, C₂, C₃ to elements P₀, P₁, P₂, P₃ and thresholds for elements P₀, P₁, P₂, P₃.

FIG. 38 shows four bit multiplication where one four bit number is y₃ y₂ y₁ y₀ and the other four bit number is z₃ z₂ z₁ z₀ and the result is e₇ e₆ e₅ e₄ e₃ e₂ e₁ e₀

FIG. 39 shows the amplitude and threshold used to compute the value of e₀.

FIG. 40 shows the firing patterns for elements S₁₀ and S₀₁ representing the value of products y₁ z₀ and y₀ z₁.

FIG. 41 shows the amplitudes from elements S₁₀ and S₀₁ to elements C₀₁ and C₁₁ and the thresholds of C₀₁ and C₁₁.

FIG. 42 shows the amplitude and threshold used to compute the value of e₁.

FIG. 43 shows the firing patterns for elements S₂₀, S₁₁, S₀₂ and C₁.

FIG. 44 shows the amplitudes from elements S₂₀, S₁₁ S₀₂, C₁₁ to elements C₀₂, C₁₂, C₂₂ C₃₂ and thresholds of C₀₂, C₁₂, C₂₂ and C₃₂.

FIG. 45 shows the amplitudes from elements C₀₂, C₁₂, C₂₂, C₃₂ to elements P₀₂, P₁₂, P₂₂ and the thresholds of elements P₀₂, P₁₂, P₂₂.

FIG. 46 shows the amplitude and threshold used to compute the value of e₂.

FIG. 47 shows the firing patterns for elements S₃₀, S₂₁, S₁₂, S₀₃, P₁₂ representing the value of products y₃ z₀, y₂ z₁, y₁ z₂ and y₀ z₃ and the carry value.

FIG. 48 shows the amplitudes from elements S₃₀, S₂₁, S₁₂ and S₀₃ to elements C₀₃, C₁₃, C₂₃, C₃₃, and C₄₃.

FIG. 49 shows the amplitudes from elements C₀₃, C₁₃, C₂₃, C₃₃, and C₄₃ to elements P₀₃, P₁₃, P₂₃ and the thresholds of elements P₀₃, P₁₃, P₂₃. FIG. 50 shows the amplitude and threshold used to compute the value of e₃.

FIG. 51 shows the firing patterns for elements S₃₁, S₂₂, S₁₃, P₁₃, P₂₂.

FIG. 52 shows the amplitudes from elements S₃₁, S₂₂, S₁₃, P₁₃, P₂₂ to elements C₀₄, C₁₄, C₂₄, C₃₄, C₄₄ and the thresholds of C₀₄, C₁₄, C₂₄, C₃₄ and C₄₄.

FIG. 53 shows the amplitudes from elements C₀₄, C₁₄, C₂₄, C₃₄, and C₄₄ to elements P₀₄, P₁₄, P₂₄ and the thresholds of elements P₀₄, P₁₄, P₂₄.

FIG. 54 shows the amplitude and threshold used to compute the value of e₄.

FIG. 55 shows the firing patterns for elements S₃₂, S₂₃, P₁₄, P₂₃.

FIG. 56 shows the amplitudes from elements S₃₂, S₂₃, P₁₄, P₂₃ to elements C₀₅, C₁₅, C₂₅, C₃₅ and the thresholds of C₀₅, C₁₅, C₂₅, C₃₅.

FIG. 57 shows the amplitudes from elements C₀₅, C₁₅, C₂₅, C₃₅ to elements P₀₅, P₁₅, P₂₅ and the thresholds of elements P₀₅, P₁₅, P₂₅.

FIG. 58 shows the amplitude and threshold used to compute the value of e₅.

FIG. 59 shows the firing patterns for elements S₃₃, P₁₅, P₂₄.

FIG. 60 shows the amplitudes from elements S₃₃, P₁₅, P₂₄ to elements C₀₆, C₁₆, C₂₆ and the thresholds of C₀₆, C₁₆, C₂₆.

FIG. 61 shows the amplitudes from elements C₀₆, C₁₆, C₂₆ to elements P₀₆, P₁₆ and the thresholds of elements P₀₆, P₁₆.

FIG. 62 shows the amplitude and threshold used to compute the value of e₆.

FIG. 63 shows some details of the four bit multiplication 1110*0111.

FIG. 64 shows some details of the four bit multiplication 1011*1001.

FIG. 65 shows some details of the four bit multiplication 1111*1110.

FIG. 66 shows some details of the four bit multiplication 1111*1111.

FIG. 67 shows an embodiment of a non-deterministic, self-modifiable computing machine. Machine 6700 consists of standard machine instructions (digital computer) 6710, meta instructions 6720, random measurements 6730, and random instructions 6740.

FIG. 68 shows a network of computers that contain hardware and software for implementing standard instructions 6710, meta instructions 6720 and quantum random measurements 6730, and quantum random instructions 6740.

FIG. 69 shows a system level diagram of random self-modifiable computing machine. In an embodiment, processor system 6970 executes standard instructions 6710. Random system 6950 implements random measurements 6730, and executes random instructions 6740. Self-Modification system 6960 executes meta instructions 6720.

FIG. 70 shows a protocol for measuring quantum randomness, which helps create non-determinism that is useful in secure computation. The protocol helps design an unpredictable physical process which can generate random bits. The quantum observables render random bits via value indefiniteness. The source is obtained from spin-1 particles.

FIG. 71 shows how an infinite binary tree is traversed so that ex-machine (x) can accept binary languages L_ƒ where ƒ:→{0,1}.

FIG. 72 shows meta instruction (q,a₁,|Q|−1,a₁,y₁,J) executing the first computational step, where instruction J=(|Q|−1,a₂,|Q|,a₂,y₂).

FIG. 73 shows the meta instruction (q,a₁,|Q|−1,a₁,y₁,J) executing the second computational step, where instruction J=(|Q|−1,a₂,|Q|,a₂,y₂).

BRIEF SUMMARY OF PRIOR ART COMPUTING MODELS AND MACHINES

For completeness, a brief introduction to Turing machines is presented in a later section. In [33], Alan Turing introduces the Turing Machine, which is a basis for the current digital computer. Sturgis and Shepherdson present the register machine in [32] 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 [3], [4], [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 cn^0.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).

Limitations and Deficiencies of Prior Art

What are the Limitations of Current 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 many orders of magnitude too slow. 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.

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 http://en.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, Go, 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.

Non-Deterministic, Self-Modifiable Machines

Consider two fundamental questions in computer science, which influence the design of current digital computers and play a fundamental role in hardware and machine-implemented software of the prior art:

• • 1. What can a computing machine compute?
  • 2. How many computational steps does a computational machine require to solve an instance of the 3-SAT problem? The 3-SAT problem [12] is the basis for the famous PNP problem [12].

Advantages Over the Prior Art

In the prior art, the two questions are typically conceived and implemented with hardware and software that compute according to the Turing machine (TM) [33] (i.e., standard digital computer [36]) model, which is the standard model of computation [7,8,12,20,24,33] in the prior art.

In this invention(s), embodiments advance beyond the prior art, by applying new machine-implemented methods and hardware to secure computation and cryptography. The machine embodiments bifurcate the first question into two questions. What is computation? What can computation compute? An machine computation adds two special types of instructions to the standard digital computer [36] instructions 6710, as shown in FIG. 67. Some embodiments are referred as an ex-machine—derived from the latin extra machinam—because ex-machine computation generates new dynamical behaviors that one may no longer recognize as a standard digital computer or typical machine.

One type of special machine instruction is meta instruction 6720 in FIG. 67. In some embodiments, meta instructions 6720 help make up Self-Modifiable system 6960, shown in FIG. 69. When an ex-machine executes a meta instruction, the meta instruction can add new states and add new instructions or replace instructions. Unlike a typical machine in the generic sense (e.g., the inclined plane, lever, pulley, wedge, wheel and axle, Archimedean screw, Galilean telescope, or bicycle), the meta instruction enables the complexity [28] of an ex-machine to increase.

The other special instruction is a random instruction 6740 in FIG. 67 that can be physically realized with quantum random measurements 6730. In some embodiments, a light emitting diode, shown in FIG. 24 and FIG. 25, emits photons that quantum random measurements 6730 detect. In other embodiments, random instruction 6740 can be realized with non-determinism, generated from a physical process such as atmospheric noise, sound, moisture, temperature measurements, pressure measurements, fluid turbulence, memory head read times in a digital computer due to air turbulence or friction in the hardware memory head, protein folding, Due to random instructions 6740, the execution behavior of two ex-machines may be distinct, even though the two ex-machines start their execution with the same input in memory, the same program instructions, the same initial machine states, and so on. Two distinct identical ex-machines may exhibit different execution behaviors even when started with identical initial conditions. When this property of the random instructions is combined with the appropriate use of meta instructions 6720, two identical machines with the same initial conditions can evolve to two different computations as the execution of each respective machine proceeds: this unpredictable behavior is quite useful in secure computations and cryptographic computations. This property makes it more challenging for an adversary to attack or tamper with the computation.

Some of the ex-machine programs provided here compute beyond the Turing barrier (i.e., beyond the computing capabilities of the digital computer). Computing beyond this barrier has advantages over the prior art, particularly for embodiments of secure computation and cryptographic computation. Furthermore, these embodiments provide machine programs for computing languages that a register machine, standard digital computer or Turing machine is not able to compute. In this invention(s), a countable set of ex-machines are explicitly specified, using standard instructions, meta instructions and random instructions. Every one of these ex-machines can evolve to compute a Turing incomputable language with probability measure 1, whenever the random measurements (trials) behave like unbiased Bernoulli trials. (A Turing machine [33] or digital computer [36] cannot compute a Turing incomputable language.)

Our invention describes a quantum random, self-modifiable computer that adds two special types of instructions to standard digital computer instructions [36] and [7,12,20,24,32,33]. Before the quantum random and meta instructions are defined, we present some preliminary notation, and specification for standard instructions.

denotes the integers. and ⁺ are the non-negative and positive integers, respectively. The finite set Q={0, 1, 2, . . . , n−1}⊂ represents the ex-machine states. This representation of the ex-machine states helps specify how new states are added to Q when a meta instruction is executed. Let ={a₁, . . . , a_n}, where each a_i represents a distinct symbol. The set A={0, 1, #}∪ consists of alphabet (memory) symbols, where # is the blank symbol and {0, 1, #}∩ is the empty set. In some ex-machines, A={0, 1, #, Y, N, a}, where a_i=Y, a₂=N, a₃=a. In some ex-machines, A={0, 1, #}, where is the empty set. The alphabet symbols are read from and written from memory. The ex-machine memory T is represented by function T:→A with an additional condition: before ex-machine execution starts, there exists an N>0 so that T(k)=# when |k|>N. In other words, this mathematical condition means all memory addresses contain blank symbols, except for a finite number of memory addresses. When this condition holds for memory T, we say that memory T is finitely bounded.

1.1 Standard Instructions

Machine Specification 1.1.

Execution of Standard Instructions 6710 in FIG. 67

The standard ex-machine instructions satisfy ⊂Q×A×Q×A×{−1, 0, 1} and a uniqueness condition: If (q₁, α₁, r₁, a₁, y₁)∈ and (q₂, α₂, r₂, a₂, y₂)∈ and (q₁, α₁, r₁, a₁, y₁) (q₂, a₂, r₂, a₂, y₂), then q₁≠q₂ or α₁≠α₂. A standard instruction I=(q, a, r, α, y) is similar to a Turing machine tuple [7,33]. When the ex-machine is in state q and the memory head is scanning alphabet symbol a=T(k) at memory address k, instruction I is executed as follows:

• • The ex-machine state moves from state q to state r.
  • The ex-machine replaces alphabet symbol a with alphabet symbol α so that T(k)=α. The rest of the memory remains unchanged.
  • If y=−1, the ex-machine moves its memory head, pointing one memory cell to the left (lower) in memory and is subsequently scanning the alphabet symbol T(k−1) at memory address k−1.
  • If y=+1, the ex-machine moves its memory head, point one memory cell to the right (higher) in memory and is subsequently scanning the alphabet symbol T(k+1) at memory address k+1.
  • If y=0, the ex-machine does not moves its memory head and is subsequently scanning the alphabet symbol T(k)=α at memory address k.

In other embodiments, standard instructions 6710 in FIG. 67 may be expressed with C syntax such as x=x+1; or z=(x+1)*y. In some embodiments, one of the standard instructions 6710 may selected may be a loop with a body of machine instructions such as:

n = 5000;
for(i = 0; i < n; i++)
{
. . . /* body of machine instructions, expressed in C. */
}

In some embodiments, random instruction 6740 may measure a random bit, called random_bit and then non-deterministically execute according to following code:

if(random_bit == 1)
C_function_1( );
else if (random_bit == 0)
C_function_2( );

In other embodiments, the standard instructions 6710 may have a programming language syntax such as assembly language, C++, Fortran, JAVA, JAVA virtual machine instructions, Go, Haskell, RISC machine instructions, Ruby, LISP and execute on hardware 204, shown in FIG. 68.

1 Ex-Machine Computer

A Turing machine [33] or digital computer program [36] has a fixed set of machine states Q, a finite alphabet A, a finitely bounded memory, and a finite set of standard ex-machine instructions that are executed according to specification 1.1. In other words, an ex-machine that uses only standard instructions [36] is computationally equivalent to a Turing machine. An ex-machine with only standard instructions is called a standard machine or digital computer. A standard machine has no unpredictability because it contains no random instructions. A standard machine does not modify its instructions as it is computing.

Random Instructions

The random instructions are subsets of Q×A×Q×{−1, 0, 1}={(q, a, r, y): q, r are in Q and a in A and y in {−1, 0, 1} } that satisfy a uniqueness condition defined below.

Machine Specification 1.2.

Execution of Random Instructions 6740 in FIG. 67

In some embodiments, the random instructions satisfy ⊂Q×A×Q×{−1, 0, 1} and the following uniqueness condition: If (q₁, α₁, r₁, y₁)∈ and (q₂, α₂, r₂, y₂)∈ and (q₁, α₁, r₁, y₁)≠(q₂, α₂, r₂, y₂), then q₁≠q₂ or α₁≠α₂. When the machine head is reading alphabet symbol a from memory and the machine is in machine state q, the random instruction (q, a, r, y) executes as follows:

• • The machine measures a random source 6730 that returns a random bit b∈{0, 1}. (In some embodiments, the source of non-determinism is a quantum phenomena. In some embodiments, quantum measurements satisfy unbiased Bernoulli trial axioms 1 and 2.)
  • In memory, alphabet symbol a is replaced with random bit b.
  • (This is why A contains both symbols 0 and 1.)
  • The machine state changes to machine state r.
  • The machine moves its memory head left if y=−1, right if y=+1, or the memory head does not move if y=0.

Repeated independent trials are called random Bernoulli trials (William Feller. An Introduction to Probability Theory and Its Applications. Volume 1, 1968.) if there are only two possible outcomes for each trial (i.e., random measurement) and the probability of each outcome remains constant for all trials. Unbiased means the probability of both outcomes is the same. The random or non-deterministic properties can be expressed mathematically as follows.

Random Measurement Property 1.

Unbiased Trials.

Consider the bit sequence (x₁ x₂ . . . ) in the infinite product space {0, 1}^N. A single outcome x_i of a bit sequence (x₁ x₂ . . . ) generated by randomness is unbiased. The probability of measuring a 0 or a 1 are equal: P(x_i=1) P(x_i=0)=½.

Random Measurement Property 2.

Stochastic Independence.

History has no effect on the next random measurement. Each outcome x, is independent of the history. No correlation exists between previous or future outcomes. This is expressed in terms of the conditional probabilities: P(x_i=1|x₁=b₁, . . . , x_i−1=b_i−1)=½ and P(x_i=0|x₁=b₁, . . . , x_i−1=b_i−1)=½ for each b_i∈{0, 1}.

In some embodiments, non-deterministic generator 142 in FIG. 23 has properties 1 and 2. In other embodiments, physical devices that are built with quantum observables according to FIG. 70 exhibit properties 1 and 2 when measurements are taken by the physical device. In some embodiments, spin-1 source, shown in FIG. 70, may come from electrons.

Section 2 provides a physical basis for the properties and a discussion of quantum randomness for some embodiments of non-determinism.

Machine instructions 1 lists a random walk machine that has only standard instructions and random instructions. Alphabet A={0, 1, #, E}. The states are Q={0, 1, 2, 3, 4, 5, 6, h}, where the halting state h=7. A valid initial memory contains only blank symbols; that is, # ##. The valid initial state is 0.

There are three random instructions: (0, #, 0, 0), (1, #, 1, 0) and (4, #, 4, 0). The random instruction (0, #, 0, 0) is executed first. If the random source measures a 1, the machine jumps to state 4 and the memory head moves to the right of memory address 0. If the random source measures a 0, the machine jumps to state 1 and the memory head moves to the left of memory address 0. Instructions containing alphabet value E provide error checking for an invalid initial memory or initial state; in this case, the machine halts with an error.

Machine Instructions 1.

Random Walk

• • ;; Comments follow two semicolons.
  • (0, #, 0, 0)
  • (0, 0, 1, 0, −1)
  • (0, 1, 4, 1, 1)
  • ;; Continue random walk to the left of memory address 0
  • (1, #, 1, 0)
  • (1, 0, 1, 0, −1)
  • (1, 1, 2, #, 1)
  • (2, 0, 3, #, 1)
  • (2, #, h, E, 0)
  • (2, 1, h, E, 0)
  • ;; Go back to state 0. Numbers of random 0's=number of random 1's.
  • (3, #, 0, #, −1)
  • ;; Go back to state 1. Numbers of random 0's>number of random 1's.
  • (3, 0, 1, 0, −1)
  • (3, 1, h, E, 0)
  • ;; Continue random walk to the right of memory address 0
  • (4, #, 4, 0)
  • (4, 1, 4, 1, 1)
  • (4, 0, 5, #, −1)
  • (5, 1, 6, #, −1)
  • (5, #, h, E, 0)
  • (5, 0, h, E, 0)
  • ;; Go back to state 0. Numbers of random 0's=number of random 1's.
  • (6, #, 0, #, 1)
  • ;; Go back to state 4. Numbers of random 1's>number of random 0's.
  • (6, 1, 4, 1, 1)
  • (6, 0, h, E, 0)

Below are 31 computational steps of the ex-machine's first execution. This random walk machine never halts when the initial memory is blank and the initial state is 0. The first random instruction executed is (0, #, 0, 0). The random source measured a 0, so the execution of this instruction is shown as (0, #, 0, 0_qr, 0). The second random instruction executed is (1, #, 1, 0). The random source measured a 1, so the execution of instruction (1, #, 1, 0) is shown as (1, #, 1, 1_qr, 0).

1st Execution of Random Walk Machine. Computational Steps 1-31.

STATE	MEMORY	MEMORY ADDRESS	INSTRUCTION
0	##### 0##	0	(0, #, 0, 0_qr, 0)
1	#### #0##	−1	(0, 0, 1, 0, −1)
1	#### 10##	−1	(1, #, 1, l_qr, 0)
2	##### 0##	0	(1, 1, 2, #, 1)
3	###### ##	1	(2, 0, 3, #, 1)
0	##### ###	0	(3, #, 0, #, −1)
0	##### 0##	0	(0, #, 0, 0_qr, 0)
1	#### #0##	−1	(0, 0, 1, 0, −1)
1	#### 00##	−1	(1, #, 1, 0_qr, 0)
1	### #00##	−2	(1, 0, 1, 0, −1)
1	### 000##	−2	(1, #, 1, 0_qr, 0)
1	## #000##	−3	(1, 0, 1, 0, −1)
1	## 1000##	−3	(1, #, 1, 1_qr, 0)
2	### 000##	−2	(1, 1, 2, #, 1)
3	#### 00##	−1	(2, 0, 3, #, 1)
1	### #00##	−2	(3, 0, 1, 0, −1)
1	### 100##	−2	(1, #, 1, 1_qr, 0)
2	#### 00##	−1	(1, 1, 2, #, 1)
3	##### 0##	0	(2, 0, 3, #, 1)
1	##### 0##	−1	(3, 0, 1, 0, −1)
1	#### 10##	−1	(1, #, 1, l_qr, 0)
2	#### #0##	0	(1, 1, 2, #, 1)
3	###### ##	1	(2, 0, 3, #, 1)
0	##### ###	0	(3, #, 0, #, −1)
0	##### 0##	0	(0, #, 0, 0_qr, 0)
1	#### #0##	−1	(0, 0, 1, 0, −1)
1	#### 00##	−1	(1, #, 1, 0_qr, 0)
1	### #00##	−2	(1, 0, 1, 0, −1)
1	### 000##	−2	(1, #, 1, 0_qr, 0)
1	## #000##	−3	(1, 0, 1, 0, −1)
1	## 1000##	−3	(1, #, 1, 1_qr, 0)

Below are the first 31 steps of the ex-machine's second execution. The first random instruction executed is (0, #, 0, 0). The random bit measured was 1, so the result of this instruction is shown as (0, #, 0, 1_qr, 0). The second random instruction executed is (1, #, 1, 0), which measured a 0, so the result of this instruction is shown as (1, #, 1, 0_qr, 0).

2nd Execution of Random Walk Machine. Computational Steps 1-31.

STATE	MEMORY	MEMORY ADDRESS	INSTRUCTION
0	## 1#####	0	(0, #, 0, 1_qr, 0)
4	##1 #####	1	(0, 1, 4, 1, 1)
4	##1 0####	1	(4, #, 4, 0_qr, 0)
5	## 1#####	0	(4, 0, 5, #, −1)
6	# #######	−1	(5, 1, 6, #, −1)
0	## ######	0	(6, #, 0, #, 1)
0	## 1#####	0	(0, #, 0, l_qr, 0)
4	##1 #####	1	(0, 1, 4, 1, 1)
4	##1 1####	1	(4, #, 4, 1_qr, 0)
4	##11 ####	2	(4, 1, 4, 1, 1)
4	##11 1###	2	(4, #, 4, 1_qr, 0)
4	##111 ###	3	(4, 1, 4, 1, 1)
4	##111 1##	3	(4, #, 4, 1_qr, 0)
4	##1111 ##	4	(4, 1, 4, 1, 1)
4	##1111 0#	4	(4, #, 4, 0_qr, 0)
5	##111 1##	3	(4, 0, 5, #, −1)
6	##11 1###	2	(5, 1, 6, #, −1)
4	##111 ###	3	(6, 1, 4, 1, 1)
4	##111 0##	3	(4, #, 4, 0_qr, 0)
5	##11 1###	2	(4, 0, 5, #, −1)
6	##1 1####	1	(5, 1, 6, #, −1)
4	##11 ####	2	(6, 1, 4, 1, 1)
4	##11 0###	2	(4, #, 4, 0_qr, 0)
5	##1 1####	1	(4, 0, 5, #, −1)
6	## 1#####	0	(5, 1, 6, #, −1)
4	##1 #####	1	(6, 1, 4, 1, 1)
4	##1 0####	1	(4, #, 4, 0_qr, 0)
5	## 1#####	0	(4, 0, 5, #, −1)
6	# #######	−1	(5, 1, 6, #, −1)
0	## ######	0	(6, #, 0, #, 1)
0	## 0#####	0	(0, #, 0, 0_qr, 0)
1	# #0#####	−1	(0, 0, 1, 0, −1)

The first and second executions of the random walk ex-machine verify our statement in the introduction: in contrast with the Turing machine, the execution behavior of the same ex-machine may be distinct at two different instances, even though each instance of the ex-machine starts its execution with the same input, stored in memory, the same initial states and same initial instructions. Hence, the ex-machine is a discrete, non-autonomous dynamical system.

Meta Instructions

Meta instructions are the second type of special instructions, as shown in 6720 of FIG. 67. The execution of a meta instruction enables the ex-machine to self-modify its instructions. This means that an ex-machine's meta instructions can add new states add new instructions or replace instructions. Formally, the meta instructions satisfy ⊂{(q, a, r, α, y, J):q∈Q and r∈Q∪{|Q|} and a, α∈A and instruction J∈∪}.

Define =∪, as the set of standard, quantum random, and meta instructions. To help describe how a meta instruction modifies in self-modification system 6960 of FIG. 69, the unique state, scanning symbol condition is defined. For any two distinct instructions chosen from at least one of the first two coordinates must differ. More precisely, all 6 of the following uniqueness conditions must hold.

• • 1. If (q₁, α₁, r₁, β₁, y₁) and (q₂, α₂, r2, β₂, y₂) are both in , then q₁≠q₂ or α₁≠α₂.
  • 2. If (q₁, α₁, r₁, β₁, y₁)∈ and (q₂, α₂, r₂, y)∈, then q₁≠q₂ or α₁≠α₂.
  • 3. If (q₁, α₁, r₁, y₁) and (q₂, α₂, r₂, y₂) are both in , then q₁≠q₂ or α₁≠α₂.
  • 4. If (q₁, α₁, r₁, y₁)∈ and (q₂, α₂, r₂, a₂, y₂, J₂)∈, then q₁≠q₂ or α₁≠α₂.
  • 5. If (q₁, α₁, r₁, β₁, y₁)∈ and (q₂, α₂, r₂, a₂, y₂, J₂)∈, then q₁≠q₂ or α₁≠α₂.
  • 6. If (q₁, α₁, r₁, a₁, y₁, J₁) and (q₂, α₂, r₂, a₂, y₂, J₂) are both in , then q₁≠q₂ or α₁≠α₂.

Before a valid machine execution starts, a hardware machine, shown as a system in FIG. 69, should be designed so that the standard, quantum random and meta instructions ∪∪ always satisfy the unique state, scanning symbol condition. This condition assures that there is no ambiguity on what machine instruction should be executed when the machine is in state q and is scanning symbol a in memory. An ambiguity could create a physical situation where no more instructions are executed: this is analogous to a flip-flop that has not yet settled upon a 0 or 1 output (i.e., Buridan's ass). Furthermore, the execution of a meta instruction preserves this uniqueness condition.

Specification 1.3 is an embodiment of self-modification system 6960 in FIG. 69. Specification 1.3 is also an embodiment of meta instructions 6720 in FIG. 67.

Machine Specification 1.3.

Execution of Meta Instructions 6720 in FIG. 67

A meta instruction (q, a, r, α, y, J) in is executed as follows.

• • The first five coordinates (q, a, r, α, y) are executed as a standard instruction according to specification 1.1 with one caveat. State q may be expressed as |Q|−c₁ and state r may be expressed as |Q| or |Q|−c₂, where 0<c₁, c₂≤|Q|. When (q, a, r, α, y) is executed, if q is expressed as |Q|−c₁, the value of q is instantiated to the current value of |Q| minus c₁. Similarly, if r is expressed as |Q| or |Q|−c₂, the value of state r is instantiated to the current value of |Q| or |Q| minus c₂, respectively.
  • Subsequently, instruction J modifies where instruction J has one of the two forms: J (q, a, r, α, y) or J=(q, a, r, y).
  • For both forms, if ∪{J} still satisfies the unique state, scanning symbol condition, then is updated to ∪{J}.
  • Otherwise, there is an instruction I in whose first two coordinates q, a, are equal to instruction J's first two coordinates. In this case, instruction J replaces instruction I in . That is, is updated to ∪{J}−{I}.

In regard to specification 1.3, embodiment 1 shows how instruction I is added to and how new states are instantiated and added to Q.

Machine Embodiment 1

Adding New Machine States

Consider the meta instruction (q, a₁, |Q|−1, α₁, y₁, J), where J (|Q|−1−1, a₂, |Q|, α₂, y₂). After the standard instruction (q, a₁, |Q|−1, α₁, y₁) is executed, this meta instruction adds one new state |Q| to the machine states Q and also adds the instruction J, instantiated with the current value of |Q|. FIG. 72 shows the execution of the first computational step for this meta instruction—for the specific values Q={0, 1, 2, 3, 4, 5, 6, 7}, A={#, 0, 1}, q=5, a₁=0, a₁=1, y₁=0, a₂=1, α₂=#, and y₂=−1. States and alphabet symbols are shown in red and blue, respectively. FIG. 73 shows the execution of the second computational step for meta instruction (q, a₁, |Q|−1, α₁, y₁, J), where J=(|Q|−1, a₂, |Q|, α₂, y₂). FIGS. 72 and 73 illustrate how new machine states are added to Q, as a result of executing the meta instruction.

In other embodiments, meta instructions 6720 in FIG. 67 may be implemented in hardware that can count the number of machine states and has instantiation hardware to instantiate a meta instruction based on the current number of states. In hardware, extra instructions created by the execution of a meta instruction can be stored in this hardware, implementing memory system 6940 of FIG. 69. In other embodiments, meta instructions 6720 in FIG. 67 may be implemented in a more abstract programming language. In some embodiments, meta instructions 6720 can be implemented the LISP programming language and executed on computing machine 204, shown in FIG. 68.

Below is an example of how meta instructions 6720 in FIG. 67 can be expressed in LISP. The following LISP code takes a lambda function, named y_plus_x with two arguments x and y and adds them. The code self-modifies lambda function y_plus_x, expressed as (lambda (y x) (+y x)) to construction a lambda function (lambda (x) (+x x)) that takes one argument x as input and doubles x.

;;
;; ex_fn.lsp
;;
;; Author: Michael Stephen Fiske
(set 'y_plus_x (lambda (y x) (+ y x)) )
(define (meta_replace_arg1_with_arg2 lambda_fn)
(letn (
(lambda_args (first lambda_fn) )
(num_args (length lambda_args) )
(arg1 (first lambda_args) )
(body (rest lambda_fn) )
(i 0)
(arg2 nil)
(fn_double_x nil)
)
(if (> num_args 1)
(set 'arg2 (first (rest lambda_args)))
)
(println “Before self-modifying lambda_fn = ” lambda_fn)
(println “args: ” lambda_args)
(println “number of arguments: ” num_args)
(println “arg1: ” arg1)
(println “Before self-modification, lambda body: ” body)
(set-ref-all arg1 body arg2)
(append (lambda) (list (list arg2)) body)
))
(define (meta_procedure lambda_fn lambda_modifier)
(lambda_modifier lambda_fn)
)
(set ’double (meta_procedure y_plus_x meta_replace_arg1_with_arg2) )
(println “After self-modification, lambda function double = ” double)
(println “(double 5) = ” (double 5) )
double

The aforementioned LISP code produces the following output when executed:

Before self-modifying lambda_fn = (lambda (y x) (+ y x))
args: (y x)
number of arguments: 2
arg1: y
Before self-modification, lambda body: ((+ y x))
After self-modification, lambda function double = (lambda (x) (+ x x))
(double 5) = 10

In the final computational step, lambda function (lambda (x) (+x x)) is returned.

Let be an ex-machine. The instantiation of |Q|−1 and |Q| in a meta instruction I (shown in 6720 of FIG. 76) invokes self-reflection about 's current number of states, at the moment when executes I. This simple type of self-reflection is straightforward in physical realizations. In particular, a physical implementation in our lab along with quantum random bits measured from a quantum random number generator [34] simulates all executions of the ex-machines provided herein.

Machine Specification 1.4.

Simple Meta Instructions

A simple meta instruction has one of the forms (q, a, |Q|−c₂, α, y), (q, a, |Q|, α, y), (|Q|−c₁, a, r, α, y), (|Q|−c₁, a, |Q|−c₂, α, y), (|Q|−c₁, a, |Q|, α, y), where 0<c₁, c₂≤|Q|. The expressions |Q|−c₁, |Q|−₂ and |Q| are instantiated to a state based on the current value of |Q| when the instruction is executed. In the embodiments in this section, ex-machines only self-reflect with the symbols |Q|−1 and |Q|. In other embodiments, an ex-machine may self-reflect with |Q|+c, where c is positive integer.

Machine Embodiment 2

Execution of Simple Meta Instructions

Let A={0, 1, #} and Q={0}. ex-machine has 3 simple meta instructions.

• (||−1, #, ||−1, 1, 0)
• (||−1, 1, ||, 0, 1)
• (||−1, 0, ||, 0, 0)

With an initial blank memory and starting state of 0, the first four computational steps are shown below. In the first step, memory head is scanning a # and the ex-machine state is 0. Since |Q|=1, simple meta instruction (|Q|−1, #, |Q|−1, 1, 0) instantiates to (0, #, 0, 1, 0), and executes.

		MEMORY		NEW
STATE	MEMORY	ADDRESS	INSTRUCTION	INSTRUCTION
0	##1###	0	(0, #, 0, 1, 0)	(0, #, 0, 1, 0)
1	##0 ###	1	(0, 1, 1, 0, 1)	(0, 1, 1, 0, 1)
1	##0 1##	1	(1, #, 1, 1, 0)	(1, #, 1, 1, 0)
2	##00 ##	2	(1, 1, 2, 0, 1)	(1, 1, 2, 0, 1)

In the second step, the memory head is scanning a 1 and the state is 0. Since |Q|=1, instruction (||−1, 1, ||, 0, 1) instantiates to (0, 1, 1, 0, 1), executes and updates Q={0, 1}. In the third step, the memory head is scanning a # and the state is 1. Since |Q|=2, instruction (||−1, #, ||−1, 1, 0) instantiates to (1, #, 1, 1, 0) and executes. In the fourth step, the memory head is scanning a 1 and the state is 1. Since |Q|=2, instruction (||−1, 1, ||, 0, 1) instantiates to (1, 1, 2, 0, 1), executes and updates Q={0, 1, 2}. During these four steps, two simple meta instructions create four new instructions and add new states 1 and 2.

Machine Specification 1.5.

Finite Initial Conditions

A machine is said to have finite initial conditions if the following conditions are satisfied by the computing hardware shown in FIGS. 66, 67, and 68 before the machine starts its execution.

• • 1. The number of machine states |Q| is finite.
  • 2. The number of alphabet symbols |A| is finite.
  • 3. The number of machine instructions || is finite.
  • 4. The memory is finitely bounded.

It may be useful to think about the initial conditions of an ex-machine as analogous to the boundary value conditions of a differential equation. While trivial to verify, the purpose of remark 1.1 is to assure computations by an ex-machine execute on different types of hardware such as semiconductor chips, lasers using photons, biological implementations using proteins, DNA and RNA. See FIG. 23, FIG. 24, FIG. 25 and FIG. 67, FIG. 68 and FIG. 69.

Remark 1.1.

Finite Initial Conditions

If the machine starts its execution with finite initial conditions, then after the machine has executed l instructions for any positive integer l, the current number of states Q(l) is finite and the current set of instructions (l) is finite. Also, the memory T is still finitely bounded and the number of measurements obtained from the random or non-deterministic source is finite.

Proof.

The remark follows immediately from specification 1.5 of finite initial conditions and machine instruction specifications 1.1, 1.2, and 1.3. In particular, the execution of one meta instruction adds at most one new instruction and one new state to Q. □

Specification 1.6 describes new ex-machines that can evolve from computations of prior ex-machines that have halted. The notion of evolving is useful because the random instructions 6740 and meta instructions 6720 can self-modify an ex-machine's instructions as it executes. In contrast with the ex-machine, after a digital computer program stops executing, its instructions have not changed.

This difference motivates the next specification, which is illustrated by the following. Consider an initial ex-machine ₀ that has 9 initial states and 15 initial instructions. ₀ starts executing on a finitely bounded memory T₀ and halts. When the ex-machine halts, it (now called ₁) has 14 states and 24 instructions and the current memory is S₁. We say that ex-machine N₀ with memory T₀ evolves to ex-machine ₁ with memory S₁.

Machine Specification 1.6.

Evolving an Ex-Machine

Let T₀, T₁, T₂ . . . T_i−1 each be a finitely bounded memory. Consider ex-machine No with finite initial conditions in the ex-machine hardware. ₀ starts executing with memory T₀ and evolves to ex-machine ₁ with memory S₁. Subsequently, ₁ starts executing with memory T₁ and evolves to ₂ with memory S₂. This means that when ex-machine ₁ starts executing on memory T₁, its instructions are preserved after the halt with memory S₁. The ex-machine evolution continues until _i−1 starts executing with memory T_i−1 and evolves to ex-machine ₂ with memory S₂. One says that ex-machine No with finitely bounded memories T₀, T₁, T₂ . . . T_i−1 evolves to ex-machine ₂ after i halts.

When an ex-machine ₀ evolves to ₁ and subsequently ₁ evolves to ₂ and so on up to ex-machine _n, then ex-machine _i is called an ancestor of ex-machine _j whenever 0≤i<j≤n. Similarly, ex-machine _j is called a descendant of ex-machine _i whenever 0≤i<j≤n. The sequence of ex-machines ₀→₁→ . . . →_n . . . is called an evolutionary path. In some embodiments, this sequence of ex-machines may be stored on distinct computing hardware, as shown in machines 214, 216, 218 and 220 of FIG. 68. In an embodiment, token 202 may contain hardware shown FIGS. 23, 24, and 25. Token 202 may provide quantum random measurements or help implement quantum random instructions that are used by machines 214, 216, 218 and 220 of FIG. 68.

2 Non-Determinism and Randomness

In some embodiments, the computing machines described in this invention use non-determinism (i.e., see) as a computational tool to make the computation unpredictable. In some embodiments, quantum random measurements are used as a computational tool. Quantum randomness is a type of non-determinism. In Based on the DIEHARD statistical tests on our implementations, according to FIGS. 23, 24 and 25, the random instructions behave according to quantum random properties 1 and 2. These statistical properties are also supported by the empirical evidence of other quantum random sources [31,34,35].

In sections 3 and 4, the execution of the standard instructions, random instructions and meta instructions uses the property that for any m, all 2^m binary strings are equally likely to occur when a quantum random number generator takes m binary measurements. One, however, has to be careful not to misinterpret quantum random properties 1 and 2.

Consider the Champernowne sequence 01 00 01 10 11 000 001 010 011 100 101 110 111 0000 . . . , which is sometimes cited as a sequence that is Borel normal, yet still Turing computable. The book An Introduction to Probability Theory and Its Applications, (William Feller. Volume 1, Third Edition. John Wiley & Sons, New York, 1968; pp. 202-211, ISBN 0 471 25708-7.) discusses the mathematics of random walks. The Champernowne sequence catastrophically fails the expected number of changes of sign for a random walk as n→∞. Since all 2^m strings are equally likely, the expected value of changes of sign follows from the reflection principle and simple counting arguments, as shown in section III.5 of Feller's book.

Furthermore, most of the 2^m binary strings (i.e., binary strings of length m) have high Kolmogorov complexity. This fact leads to the following mathematical intuition that enables new computational behaviors that a standard digital computer cannot perform. The execution of quantum random instructions working together with meta instructions enables the ex-machine to increase its program complexity [28] as it evolves. In some cases, the increase in program complexity can increase the ex-machine's computational power as the ex-machine evolves. Also, notice the distinction here between the program complexity of the ex-machine and Kolmogorov complexity. The definition of Kolmogorov complexity only applies to standard machines. Moreover, the program complexity (e.g., the Shannon complexity |Q∥A|) stays fixed for standard machines. In contrast, an ex-machine's program complexity can increase without bound, when the ex-machine executes quantum random and meta instructions that productively work together. (For example, see ex-machine 1, called (x).)

In terms of the ex-machine computation performed, how one of these binary strings is generated from some particular type of non-deterministic process is not the critical issue. Suppose the quantum random generator demonstrated measuring the spin of particles, certified by the strong Kochen-Specker theorem [5,6] outputs the 100-bit string a₀ a₁ . . . a₉₉=10110000101011110011001100111000100011100101010110111100 00000010011001000011010101101111001101010000 to ex-machine ₁.

Suppose a distinct quantum random generator using radioactive decay outputs the same 100-bit string a₀ a₁ . . . a₉₉ to a distinct ex-machine ₂. Suppose ₁ and ₂ have identical programs with the same initial tapes and same initial state. Even though radioactive decay was discovered over 100 years ago and its physical basis is still phenomenological, the execution behavior of ₁ and ₂ are indistinguishable for the first 100 executions of their quantum random instructions. In other words, ex-machines ₁ and ₂ exhibit execution behaviors that are independent of the quantum process that generates these two identical binary strings.

2.1 Mathematical Determinism and Unpredictability

Before some of the deeper theory on quantum randomness is reviewed, we take a step back to view randomness from a broader theoretical perspective. While we generally agree with the philosophy of Eagle (Antony Eagle. Randomness Is Unpredictability. British Journal of Philosophy of Science. 56, 2005, pp. 749-790.) that randomness is unpredictablity, embodiment 3 helps sharpen the differences between indeterminism and unpredictability.

Machine Embodiment 3

A Mathematical Gedankenexperiment

Our gedankenexperiment demonstrates a deterministic system which exhibits an extreme amount of unpredictability. This embodiment shows that a physical system whose mathematics is deterministic can still be an extremely unpredictable process if the measurements of the process has limited resolution. Some mathematical work is needed to define the dynamical system and summarize its mathematical properties before we can present the gedankenexperiment.

Consider the quadratic map ƒ:→, where ƒ(x)= 9/2x(1−x). Set I₀ [0, ⅓] and I₁=[⅓, ⅔]. Set B=(⅓, ⅔). Define the set A={x∈[0, 1]: ƒⁿ(x)∈I₀∪I₁ for all n∈}. 0 is a fixed point of ƒ and ƒ²(⅓)=ƒ²(⅔)=0, so the boundary points of B lie in Λ. Furthermore, whenever x∈B, then ƒ(x)<0 and

$\begin{array}{cc}\underset{n\to \infty }{\lim }{f}^n\left(x\right)=-\infty .& \end{array}$ This means all orbits that exit Λ head off to −∞.

The inverse image ƒ⁻¹(B) is two open intervals B₀⊂I₀ and B₁⊂I₁ such that ƒ(B₀)=ƒ(B₁)=B. Topologically, B₀ behaves like Cantor's open middle third of I₀ and B₁ behaves like Cantor's open middle third of I₁. Repeating the inverse image indefinitely, define the set

$H=B\bigcup \underset{k=1}{\bigcup ^{\infty }}{f}^{-k}\left(B\right).$ Now H∪Λ=[0,1] and H∩Λ=∅.

Using dynamical systems notation, set Σ₂={0, 0. Define the shift map σ:Σ₂→Σ₂, where σ(a₀ a₁ . . . ) (a₁a₂ . . . ). For each x in Λ, x's trajectory in I₀ and I₁ corresponds to a unique point in Σ₂: define h:Λ→Σ₂ as h(x) (a₀ a₁ . . . ) such that for each n∈, set a_n=0 if ƒⁿ(x)∈I₀ and a_n=1 if ƒⁿ(x)∈I₁.

For any two points (a₀ a₁ . . . ) and (b₀b₁ . . . ) in Σ₂, define the metric d((a₀ a₁ . . . ),

$(b_0{b}_1...))=\sum _{i=0}^{\infty }\left|a_i-b_i\right|2^{-i}.$ Via the standard topology on inducing the subspace topology on Λ, it is straightforward to verify that h is a homeomorphism from Λ to Σ₂. Moreover, h∘ƒ=σ∘h, so h is a topological conjugacy. The set H and the topological conjugacy h enable us to verify that Λ is a Cantor set. This means that Λ is uncountable, totally disconnected, compact and every point of Λ is a limit point of Λ.

We are ready to pose our mathematical gedankenexperiment. We make the following assumption about our mathematical observer. When our observer takes a physical measurement of a point x in Λ₂, she measures a 0 if x lies in I₀ and measures a 1 if x lies in I₁. We assume that she cannot make her observation any more accurate based on our idealization that is analogous to the following: measurements at the quantum level have limited resolution due to the wavelike properties of matter (Louis de Broglie. Recherches sur la theorie des quanta. Ph.D. Thesis. Paris, 1924.) Similarly, at the second observation, our observer measures a 0 if ƒ(x) lies in I₀ and 1 if ƒ(x) lies in I₁. Our observer continues to make these observations until she has measured whether ƒ^k−1(X) is in I₀ or in I₁. Before making her k+1st observation, can our observer make an effective prediction whether ƒ^k(X) lies in I₀ or I₁ that is correct for more than 50% of her predictions?

The answer is no when h(x) is a generic point (i.e., in the sense of Lebesgue measure) in Σ₂. Set to the Martin-Löf random points in Σ₂. Then has Lebesgue measure 1 (Feller, Volume 1) in Σ₂, so its complement Σ₂− has Lebesgue measure 0. For any x such that h(x) lies in , then our observer cannot predict the orbit of x with a Turing machine. Hence, via the topological conjugacy h, we see that for a generic point x in Λ, x's orbit between I₀ and I₁ is Martin-Löf random—even though ƒ is mathematically deterministic and ƒ is a Turing computable function.

Overall, the dynamical system (ƒ, Λ) is mathematically deterministic and each real number x in Λ has a definite value. However, due to the lack of resolution in the observer's measurements, the orbit of generic point x is unpredictable—in the sense of Martin-Löf random.

2.2 Quantum Random Theory

The standard theory of quantum randomness stems from the seminal EPR paper. Einstein, Podolsky and Rosen propose a necessary condition for a complete theory of quantum mechanics: Every element of physical reality must have a counterpart in the physical theory. Furthermore, they state that elements of physical reality must be found by the results of experiments and measurements. While mentioning that there might be other ways of recognizing a physical reality, EPR propose the following as a reasonable criterion for a complete theory of quantum mechanics:

• • If, without in any way disturbing a system, one can predict with certainty (i.e., with probability equal to unity) the value of a physical quantity, then there exists an element of physical reality corresponding to this physical quantity.

They consider a quantum-mechanical description of a particle, having one degree of freedom. After some analysis, they conclude that a definite value of the coordinate, for a particle in the state given by

$\psi =e^{\frac{2\pi i}{h}{p}_{o}x},$ is not predictable, but may be obtained only by a direct measurement. However, such a measurement disturbs the particle and changes its state. They remind us that in quantum mechanics, when the momentum of the particle is known, its coordinate has no physical reality. This phenomenon has a more general mathematical condition that if the operators corresponding to two physical quantities, say A and B, do not commute, then a precise knowledge of one of them precludes a precise knowledge of the other. Hence, EPR reach the following conclusion:

• • (I) The quantum-mechanical description of physical reality given by the wave function is not complete. OR
  • (II) When the operators corresponding to two physical quantities (e.g., position and momentum) do not commute (i.e. AB≠BA), the two quantities cannot have the same simultaneous reality.

EPR justifies this conclusion by reasoning that if both physical quantities had a simultaneous reality and consequently definite values, then these definite values would be part of the complete description. Moreover, if the wave function provides a complete description of physical reality, then the wave function would contain these definite values and the definite values would be predictable.

From their conclusion of I OR II, EPR assumes the negation of I—that the wave function does give a complete description of physical reality. They analyze two systems that interact over a finite interval of time. And show by a thought experiment of measuring each system via wave packet reduction that it is possible to assign two different wave functions to the same physical reality. Upon further analysis of two wave functions that are eigenfunctions of two non-commuting operators, they arrive at the conclusion that two physical quantities, with non-commuting operators can have simultaneous reality. From this contradiction or paradox (depending on one's perspective), they conclude that the quantum-mechanical description of reality is not complete.

In the paper—Can Quantum-Mechanical Description of Physical Reality be Considered Complete? Physical Review. 48, Oct. 15, 1935, pp. 696-702—Neil Bohr responds to the EPR paper. Via an analysis involving single slit experiments and double slit (two or more) experiments, Bohr explains how during position measurements that momentum is transferred between the object being observed and the measurement apparatus. Similarly, Bohr explains that during momentum measurements the object is dis-placed. Bohr also makes a similar observation about time and energy: “it is excluded in principle to control the energy which goes into the clocks without interfering essentially with their use as time indicators”. Because at the quantum level it is impossible to control the interaction between the object being observed and the measurement apparatus, Bohr argues for a “final renunciation of the classical ideal of causality” and a “radical revision of physical reality”.

From his experimental analysis, Bohr concludes that the meaning of EPR's expression without in any way disturbing the system creates an ambiguity in their argument. Bohr states: “There is essentially the question of an influence on the very conditions which define the possible types of predictions regarding the future behavior of the system. Since these conditions constitute an inherent element of the description of any phenomenon to which the term physical reality can be properly attached, we see that the argumentation of the mentioned authors does not justify their conclusion that quantum-mechanical description is essentially incomplete.” Overall, the EPR versus Bohr-Born-Heisenberg position set the stage for understanding whether hidden variables can exist in the theory of quantum mechanics.

Embodiments of quantum random instructions utilize the lack of hidden variables because this contributes to the unpredictability of quantum random measurements. In some embodiments of the quantum random measurements used by the quantum random instructions, the lack of hidden variables are only associated with the quantum system being measured and in other embodiments the lack of hidden variables are associated with the measurement apparatus. In some embodiments, the value indefiniteness of measurement observables implies unpredictability. In some embodiments, the unpredictability of quantum measurements 6730 in FIG. 67 depend upon Kochen-Specker type theorems [5,6]. In some embodiments, the unpredictability of quantum measurements 6730 in FIG. 67 depend upon Bell type theorems [2].

In an embodiment of quantum random measurements 6730 shown in FIG. 67, a protocol for two sequential measurements that start with a spin-1 source is shown in FIG. 70. Spin-1 particles are prepared in the S_z=0 state. (From their eigenstate assumption, this operator has a definite value.) Specifically, the first measurement puts the particle in the S_z=0 eigenstate of the spin operator S_z. Since the preparation state is an eigenstate of the S_x=0 projector observable with eigenvalue 0, this outcome has a definite value and theoretically cannot be reached. The second measurement is performed in the eigenbasis of the S_x operator with two outcomes S_x=±1.

The S_x=±1 outcomes can be assigned 0 and 1, respectively. Moreover, since

$\langle S_z=0|S_x=\pm 1\rangle =\frac{1}{\sqrt{2}},$ neither of the S_x±1 outcomes can have a pre-determined definite value. As a consequence, bits 0 and 1 are generated independently (stochastic independence) with a 50/50 probability (unbiased). These are quantum random properties 1 and 2.

3 Computing Ex-Machine Languages

A class of ex-machines are defined as evolutions of the fundamental ex-machine (x), whose 15 initial instructions are listed in ex-machine specification 1. These ex-machines compute languages L that are subsets of {a}*={aⁿ:n∈}. The expression aⁿ represents a string of n consecutive a's. For example, a₅=aaaaa and a⁰ is the empty string. Define the set of languages

$𝔏=\bigcup _{L⋐{\left\{a\right\}}^{*}}\left\{L\right\}.$

Machine Specification 3.1 defines a unique language in for each function ƒ:→{0, 1}.

Machine Specification 3.1.

Language L_ƒ

Consider any function ƒ:→{0, 1}. This means ƒ is a member of the set {0, 1. Function ƒ induces the language L_ƒ={aⁿ: ƒ(n)=1}. In other words, for each non-negative integer n, string aⁿ is in the language L_ƒ if and only if ƒ(n)=1.

Trivially, L_ƒ is a language in . Moreover, these functions ƒ generate all of .

Remark 3.1.

$𝔏=\bigcup _{f\in {\left\{0,1\right\}}^{\mathbb{N}}}\left\{L_f\right\}$

In order to define the halting syntax for the language in that an ex-machine computes, choose alphabet set A={#, 0, 1, N, Y, a}.

Machine Specification 3.2.

Language L in that Ex-Machine Computes

Let be an ex-machine. The language L in that computes is defined as follows. A valid initial tape has the form # #aⁿ#. The valid initial tape # ## represents the empty string. After machine starts executing with initial tape # #aⁿ#, string an is in 's language if ex-machine halts with tape #aⁿ# Y#. String aⁿ is not in 's language if halts with tape #aⁿ# N#.

The use of special alphabet symbols (i.e., special memory values) Y and N—to decide whether aⁿ is in the language or not in the language—follows [?].

For a particular string # #a^m#, some ex-machine IX could first halt with #a^m# N# and in a second computation with input # #a_m# could halt with #a^m# Y#. This oscillation of halting outputs could continue indefinitely and in some cases the oscillation can be aperiodic. In this case, 's language would not be well-defined according to machine specification 3.2. These types of ex-machines will not be specified in this invention.

There is a subtle difference between (x) and an ex-machine IX whose halting output never stabilizes. In contrast to the Turing machine or a digital computer program, two different instances of the ex-machine (x) can evolve to two different machines and compute distinct languages according to machine specification 3.2. However, after (x) has evolved to a new machine (a₀ a₁ . . . a_m x) as a result of a prior execution with input tape # #a^m#, then for each i with 0≤i≤m, machine (a₀ a₁ . . . a_m x) always halts with the same output when presented with input tape # #aⁱ#. In other words, (a₀ a₁ . . . a_m x)'s halting output stabilizes on all input strings aⁱ where 0≤i≤m. Furthermore, it is the ability of (x) to exploit the non-autonomous behavior of its two quantum random instructions that enables an evolution of (x) to compute languages that are Turing incomputable (i.e., not computable by a standard digital computer).

We designed ex-machines that compute subsets of {a}* rather than subsets of {0, 1}* because the resulting specification of (x) is much simpler and more elegant. It is straightforward to list a standard machine that bijectively translates each an to a binary string in {0, 1}* as follows. The empty string in {a}* maps to the empty string in {0, 1}*. Let ψ represent this translation map. Hence, a0, aa1, aaa00, a⁴01, a⁵10, a⁶11, a⁷000, and so on. Similarly, an inverse translation standard machine computes the inverse of ψ. Hence 0a, 1aa, 00aaa, and so on. The translation and inverse translation computations immediately transfer any results about the ex-machine computation of subsets of {a}* to corresponding subsets of {0, 1}* via ψ. In particular, the following remark is relevant for our discussion.

Remark 3.2.

Every subset of {a}* is computable by some ex-machine if and only if every subset of {0, 1}* is computable by some ex-machine.

Proof.

The remark immediately follows from the fact that the translation map ψ and the inverse translation map ψ⁻¹ are computable with a standard machine. □

When the quantum randomness in 's two quantum random instructions satisfy property 1 (unbiased bernoulli trials) and property 2 (stochastic independence), for each n∈, all 2ⁿ finite paths of length n—in the infinite, binary tree of FIG. 71—are equally likely. (See Feller, Introduction to Probability Theory and its Applications, volumes 1 and 2 for a comprehensive study of random walks.)

Moreover, there is a one-to-one correspondence between a function ƒ:→{0, 1} and an infinite downward path in the infinite binary tree of FIG. 71. The beginning of a particular infinite downward path is shown in red; it starts as (0, 1, 1, 0 . . . ). Based on this one-to-one correspondence between functions ƒ:→{0,1} and downward paths in the infinite binary tree, an examination of (x)'s execution behavior will show that (x) can evolve to compute any language L_ƒ in when quantum random instructions (x, #, x, 0) and (x, a, t, 0) satisfy properties 1 and 2.

Machine Specification 1.

(x)

A={#, 0, 1, N, Y, a}. States Q={0, h, n, y, t, v, w, x, 8} where halting state h=1, and states n=2, y=3, t=4, v=5, w=6, x=7. The initial state is always 0. The letters are used to represent machine states instead of explicit numbers because these states have special purposes. (This is for the reader's benefit.) State n indicates NO that the string is not in the machine's language. State y indicates YES that the string is in the machine's language. State x is used to generate a new random bit; this random bit determines the string corresponding to the current value of |Q|−1. The fifteen instructions of (x) are shown below.

• • (0, #, 8, #, 1)
  • (8, #, x, #, 0)
  • (y, #, h, Y, 0)
  • (n, #, h, N, 0)
  • (x, #, x, 0)
  • (x, a, t, 0)
  • (x, 0, v, #, 0, (||−1, #, n, #, 1))
  • (x, 1, w, #, 0, (||−1, #, y, #, 1))
  • (t, 0, w, a, 0, (||−1, #, n, #, 1))
  • (t, 1, w, a, 0, (||−1, #, y, #, 1))
  • (v, #, n, #, 1, (|Q|−1, a, ||, a, 1))
  • (w, #, y, #, 1, (||−1, a, ||, a, 1))
  • (w, a, ≡|, a, 1, (||−1, a, ||, a, 1))
  • (||−1, a, x, a, 0)
  • (||−1, #, x, #, 0)

With initial state 0 and initial memory # #aaaa##, an execution of machine (x) is shown below.

STATE	MEMORY	ADDRESS	INSTRUCTION	NEW INSTRUCTION
8	## aaaa###	1	(0, #, 8, #, 1)
x	## aaaa###	1	(8, a, x, a, 0)
t	## 1aaa###	1	(x, a, t, 1_qr, 0)
w	## aaaa###	1	(t, 1, w, a, 0, (|   |-1, #, y, #, 1))	(8, #, y, #, 1)
9	##a aaaa###	2	(w, a, |   |, a, 1, (|   |-1, a, |   |, a, 1))	(8, a, 9, a, 1)
x	##a aaa###	2	(9, a, x, a, 0)	(9, a, x, a, 0)
t	##a 1aa###	2	(x, a, t, 1_qr, 0)
w	##a aaa###	2	(t, 1, w, a, 0, (|   |-1, #, y, #, 1) )	(9, #, y, #, 1)
10	##aa aa###	3	(w, a, |   |, a, 1, (|   |-1, a, |   |, a, 1))	(9, a, 10, a, 1)
x	##aa aa###	3	(10, a, x, a, 0)	(10, a, x, a, 0)
t	##aa 0a###	3	(x, a, t, 0_qr, 0)
w	##aa aa###	3	(t, 0, w, a, 0, (|   |-1, #, n, #, 1) )	(10, #, n, #, 1)
11	##aaa a###	4	(w, a, |   |, a, 1, (|   |-1, a, |   |, a, 1))	(10, a, 11, a, 1)
x	##aaa a###	4	(11, a, x, a, 0)	(11, a, x, a, 0)
t	##aaa 1###	4	(x, a, t, 1_qr, 0)
w	##aaa a###	4	(t, 1, w, a, 0, (|   |-1, #, y, #, 1) )	(11, #, y, #, 1)
12	##aaaa ###	5	(w, a, |   |, a, 1, (|   |-1, a, |   |, a, 1))	(11, a, 12, a, 1)
x	##aaaa ###	5	(12, #, x, #, 0)	(12, #, x, #, 0)
x	##aaaa 0##	5	(x, #, x, 0_qr, 0)
v	##aaaa ###	5	(x, 0, v, #, 0, (|   |-1, #, n, #, 1) )	(12, #, n, #, 1)
n	##aaaa# ##	6	(v, #, n, #, 1, (|   |-1, a, |   |, a, 1))	(12, a, 13, a, 1)
h	##aaaa# N#	6	(n, #, h, N, 0)

During this execution, (x) replaces instruction (8, #, x, #, 0) with (8, #, y, #, 1). Meta instruction (w, a, ||, a, 1, (||−1, a, ||, a, 1)) executes and replaces (8, a, x, a, 0) with new instruction (8, a, 9, a, 1). Also, simple meta instruction (||−1, a, x, a, 0) temporarily added instructions (9, a, x, a, 0), (10, a, x, a, 0), and (11, a, x, a, 0).

Subsequently, these new instructions were replaced by (9, a, 10, a, 1), (10, a, 11, a, 1), and (11, a, 12, a, 1), respectively. Similarly, simple meta instruction (||−1, #, x, #, 0) added instruction (12, #, x, #, 0) and this instruction was replaced by instruction (12, #, n, #, 1). Lastly, instructions (9, #, y, #, 1), (10, #, n, #, 1), (11, #, y, #, 1), and (12, a, 13, a, 1) were added.

Furthermore, five new states 9, 10, 11, 12 and 13 are added to Q. After this computation halts, the machine states are Q={0, h, n, y, t, v, w, x, 8, 9, 10, 11, 12, 13} and the resulting ex-machine evolved to has 24 instructions. It is called (11010 x).

Machine Instructions 2.

(11010 x)

• • (0, #, 8, #, 1)
  • (y, #, h, Y, 0)
  • (n, #, h, N, 0)
  • (x, #, x, 0)
  • (x, a, t, 0)
  • (x, 0, v, #, 0, (||−1, #, n, #, 1))
  • (x, 1, w, #, 0, (||−1, #, y, #, 1))
  • (t, 0, w, a, 0, (||−1, #, n, #, 1))
  • (t, 1, w, a, 0, (||−1, #, y, #, 1))
  • (v, #, n, #, 1, (||−1, a, ||, a, 1))
  • (w, #, y, #, 1, (||−1, a, ||, a, 1))
  • (w, a, ||, a, 1, (||−1, a, ||, a, 1))
  • (||−1, a, x, a, 0)
  • (||−1, #, x, #, 0)
  • (8, #, y, #, 1)
  • (8, a, 9, a, 1)
  • (9, #, y, #, 1)
  • (9, a, 10, a, 1)
  • (10, #, n, #, 1)
  • (10, a, 11, a, 1)
  • (11, #, v, #, 1)
  • (11, a, 12, a, 1)
  • (12, #, n, #, 1)
  • (12, a, 13, a, 1)

New instructions (8, #, y, #, 1), (9, #, y, #, 1), and (11, #, y, #, 1) help (11010 x) compute that the empty string, a and aaa are in its language, respectively. Similarly, the new instructions (10, #, n, #, 1) and (12, #, n, #, 1) help (11010 x) compute that aa and aaaa are not in its language, respectively.

The zeroth, first, and third 1 in (11010 x)'s name indicate that the empty string, a and aaa are in (11010 x)'s language. The second and fourth 0 indicate strings aa and aaaa are not in its language. The symbol x indicates that all strings an with n≥5 have not yet been determined whether they are in (11010 x)'s language or not in its language.

Starting at state 0, ex-machine (11010 x) computes that the empty string is in (11010 x)'s language.

	STATE	MEMORY	MEMORY ADDRESS	INSTRUCTION
	8	## ###	1	(0, #, 8, #, 1)
	y	### ##	2	(8, #, y, #, 1)
	h	### Y#	2	(y, #, h, Y, 0)

Starting at state 0, ex-machine (11010 x) computes that string a is in (11010 x)'s language.

	STATE	MEMORY	MEMORY ADDRESS	INSTRUCTION
	8	## a###	1	(0, #, 8, #, 1)
	9	##a ###	2	(8, a, 9, a, 1)
	y	##a# ##	3	(9, #, y, #, 1)
	h	##a# Y#	3	(y, #, h, Y, 0)

Starting at state 0, (11010 x) computes that string aa is not in (11010 x)'s language.

	STATE	MEMORY	MEMORY ADDRESS	INSTRUCTION
	8	## aa###	1	(0, #, 8, #, 1)
	9	##a a###	2	(8, a, 9, a, 1)
	10	##aa ###	3	(9, a, 10, a, 1)
	n	##aa# ##	4	(10, #, n, #, 1)
	h	##aa# N#	4	(n, #, h, N, 0)

Starting at state 0, (11010 x) computes that aaa is in (11010 x)'s language.

	STATE	MEMORY	MEMORY ADDRESS	INSTRUCTION
	8	## aaa###	1	(0, #, 8, #, 1)
	9	##a aa###	2	(8, a, 9, a, 1)
	10	##aa a###	3	(9, a, 10, a, 1)
	11	##aaa ###	4	(10, a, 11, a, 1)
	Y	##aaa# ##	5	(11, #, y, #, 1)
	h	##aaa# Y#	5	(y, #, h, Y, 0)

Starting at state 0, (11010 x) computes that aaaa is not in (11010 x)'s language.

STATE	MEMORY	MEMORY ADDRESS	INSTRUCTION
8	## aaaa####	1	(0, #, 8, #, 1)
9	##a aaa####	2	(8, a, 9, a, 1)
10	##aa aa####	3	(9, a, 10, a, 1)
11	##aaa a####	4	(10, a, 11, a, 1)
12	##aaaa ####	5	(11, a, 12, a, 1)
n	##aaaa# ###	6	(12, #, n, #, 1)
h	##aaaa# N##	6	(n, #, h, N, 0)

Note that for each of these executions, no new states were added and no instructions were added or replaced. Thus, for all subsequent executions, ex-machine (11010 x) computes that the empty string, a and aaa are in its language. Similarly, strings aa and aaaa are not in (11010 x)'s language for all subsequent executions of (11010 x).

Starting at state 0, we examine an execution of ex-machine (11010 x) on input memory # #aaaaaaa##.

				NEW
STATE	MEMORY	ADDRESS	INSTRUCTION	INSTRUCTION
8	## aaaaaaa###	1	(0, #, 8, #, 1)
9	##a aaaaaa###	2	(8, a, 9, a, 1)
10	##aa aaaaa###	3	(9, a, 10, a, 1)
11	##aaa aaaa###	4	(10, a, 11, a, 1)
12	##aaaa aaa###	5	(11, a, 12, a, 1)
13	##aaaaa aa###	6	(12, a, 13, a, 1)
x	##aaaaa aa###	6	(13, a, x, a, 0)
t	##aaaaa 0a###	6	(x, a, t, 0_qr, 0)
w	##aaaaa aa###	6	(t, 0, w, a, 0, (|Q|-1, #, n, #, 1) )	(13, #, n, #, 1)
14	##aaaaaa a###	7	(w, a, |Q|, a, 1, (|Q|-1, a, |Q|, a, 1))	(13, a, 14, a, 1)
x	##aaaaaa a###	7	(14, a, x, a, 0)	(14, a, x, a, 0)
t	##aaaaaa 1###	7	(x, a, t, 1_qr, 0)
w	##aaaaaa a###	7	(t, 1, w, a, 0, (|Q|-1, #, y, #, 1) )	(14, #, y, #, 1)
15	##aaaaaaa ###	8	(w, a, |Q|, a, 1, (|Q|-1, a, |Q|, a, 1))	(14, a, 15, a, 1)
x	##aaaaaaa ###	8	(15, #, x, #, 0)	(15, #, x, #, 0)
x	##aaaaaaa 1##	8	(x, #, x, 1_qr, 0)
w	##aaaaaaa ###	8	(x, 1, w, #, 0, (|Q|-1, #, y, #, 1))	(15, #, y, #, 1)
y	##aaaaaaa# ##	9	(w, #, y, #, 1, (|Q|-1, a, |Q|, a, 1))	(15, a, 16, a, 1)
h	##aaaaaaa# Y#	9	(y, #, h, Y, 0)

Overall, during this execution ex-machine (11010 x) evolved to ex-machine (11010 011 x). Three quantum random instructions were executed. The first quantum random instruction (x, a, t, 0) measured a 0 so it is shown above as (x, a, t, 0_qr, 0). The result of this 0 bit measurement adds the instruction (13, #, n, #, 1), so that in all subsequent executions of ex-machine (11010 011 x), string as is not in (11010 011 x)'s language. Similarly, the second quantum random instruction (x, a, t, 0) measured a 1 so it is shown above as (x, a, t, 1_qr, 0). The result of this 1 bit measurement adds the instruction (14, #, y, #, 1), so that in all subsequent executions, string a⁶ is in (11010 011 X)'s language. Finally, the third quantum random instruction (x, #, x, 0) measured a 1 so it is shown above as (x, #, x, 1_qr, 0). The result of this 1 bit measurement adds the instruction (15, #, y, #, 1), so that in all subsequent executions, string a⁷ is in (11010 011 x)'s language.

Lastly, starting at state 0, we examine a distinct execution of ex-machine (11010 x) on input memory # #aaaaaaa##. A distinct execution of (11010 x) evolves to ex-machine (11010 000 x).

STATE	MEMORY	ADDRESS	INSTRUCTION	NEW INSTRUCTION
8	## aaaaaaa###	1	(0, #, 8, #, 1)
9	##a aaaaaa###	2	(8, a, 9, a, 1)
10	##aa aaaaa###	3	(9, a, 10, a, 1)
11	##aaa aaaa###	4	(10, a, 11, a, 1)
12	##aaaa aaa###	5	(11, a, 12, a, 1)
13	##aaaaa aa###	6	(12, a, 13, a, 1)
x	##aaaaa aa###	6	(13, a, x, a, 0)
t	##aaaaa 0a###	6	(x, a, t, 0_qr, 0)
w	##aaaaa aa###	6	(t, 0, w, a, 0, (|Q|-1, #, n, #, 1))	(13, #, n, #, 1)
14	##aaaaaa a###	7	(w, a, |Q|, a, 1, (|Q|-1, a, |Q|, a, 1))	(13, a, 14, a, 1)
x	##aaaaaa a###	7	(14, a, x, a, 0)	(14, a, x, a, 0)
t	##aaaaaa 0###	7	(x, a, t, 0_qr, 0)
w	##aaaaaa a###	7	(t, 0, w, a, 0, (|Q|-1, #, n, #, 1))	(14, #, n, #, 1)
15	##aaaaaaa ###	8	(w, a, |Q|, a, 1, (|Q|-1, a, |Q|, a, 1))	(14, a, 15, a, 1)
x	##aaaaaaa ###	8	(15, #, x, #, 0)	(15, #, x, #, 0)
x	##aaaaaaa 0##	8	(x, #, x, 0_qr, 0)
v	##aaaaaaa ###	8	(x, 0, v, #, 0, (|Q|-1, #, n, #, 1))	(15, #, n, #, 1)
n	##aaaaaaa# ##	9	(v, #, n, #, 1, (|Q|-1, a, |Q|, a, 1))	(15, a, 16, a, 1)
h	##aaaaaaa# N#	9	(n, #, h, N, 0)

Based on our previous examination of ex-machine (x) evolving to (11010 x) and then subsequently (11010 x) evolving to (11010 011 x), ex-machine 2 specifies (a₀ a₁ . . . a_m x) in terms of initial machine states and initial machine instructions.

Machine Specification 2.

(a₀ a₁ . . . a_m x)

Let m∈. Set Q={0, h, n, y, t, v, w, x, 8, 9, 10, . . . m+8, m+9}. For 0≤i≤m, each a, is 0 or 1. ex-machine (a₀ a₁ . . . a_m x)'s instructions are shown below. Symbol b₈=y if a₀=1. Otherwise, symbol b₈=n if a₀=0. Similarly, symbol b₉=y if a₁=1. Otherwise, symbol b₉=n if a₁=0. And so on until reaching the second to the last instruction (m+8, #, b_m+8, #, 1), symbol b_m+8 y if a_m=1. Otherwise, symbol b_m+8 n if a_m=0.

• • (0, #, 8, #, 1)
  • (y, #, h, Y, 0)
  • (n, #, h, N, 0)
  • (x, #, x, 0)
  • (x, a, t, 0)
  • (x, 0, v, #, 0, (||−1, #, n, #, 1))
  • (x, 1, w, #, 0, (||−1, #, y, #, 1))
  • (t, 0, w, a, 0, (||−1, #, n, #, 1))
  • (t, 1, w, a, 0, (||−1, #, y, #, 1))
  • (v, #, n, #, 1, (||−1, a, ||, a, 1))
  • (w, #, y, #, 1, (||−1, a, ||, a, 1))
  • (w, a, ||, a, 1, (||−1, a, ||, a, 1))
  • (||−1, a, x, a, 0)
  • (||−1, #, x, #, 0)
  • (8, #, b₈, #, 1)
  • (8, a, 9, a, 1)
  • (9, #, b₉, #, 1)
  • (9, a, 10, a, 1)
  • (10, #, b₁₀, #, 1)
  • (10, a, 11, a, 1)
  • . . .
  • (i+8, #, b_i+8, #, 1)
  • (i+8, a, i+9, a, 1)
  • . . .
  • (m+7, #, b_m+7, #, 1)
  • (m+7, a, m+8, a, 1)
  • (m+8, #, b_m+8, #, 1)
  • (m+8, a, m+9, a, 1)

Machine Computation Property 3.1.

Whenever i satisfies 0≤i≤m, string aⁱ is in (a₀ a₁ . . . a_m x)'s language if a_i=1; string aⁱ is not in (a₀ a₁ . . . a_m x) 's language if a_i=0. Whenever n>m, it has not yet been determined whether string aⁿ is in (a₀ a₁ . . . a_m x) 's language or not in its language.

Proof.

When 0≤i≤m, the first consequence follows immediately from the definition of aⁱ being in (a₀ a₁ . . . a_m x)'s language and from ex-machine 2. In instruction (i+8, #, b_i+8, #, 1) the state value of b_i+8 is y if a_i=1 and b_i+8 is n if a_i=0.

For the indeterminacy of strings aⁿ when n>m, ex-machine (a₀ . . . a_m x) executes its last instruction (m+8, a, m+9, a, 1) when it is scanning the mth a in aⁿ. Subsequently, for each a on the memory to the right (higher memory addresses) of #a^m, ex-machine (a₀ . . . a_m x) executes the quantum random instruction (x, a, t, 0).

If the execution of (x, a, t, 0) measures a 0, the two meta instructions (t, 0, w, a, 0, (||−1, #, n, #, 1)) and (w, a, ||, a, 1, (||−1, a, ||, a, 1)) are executed. If the next alphabet symbol to the right is an a, then a new standard instruction is executed that is instantiated from the simple meta instruction (||−1, a, x, a, 0). If the memory address was pointing to the last a in aⁿ, then a new standard instruction is executed that is instantiated from the simple meta instruction (||−1, #, x, #, 0).

If the execution of (x, a, t, 0) measures a 1, the two meta instructions (t, 1, w, a, 0, (||−1, #, y, #, 1)) and (w, a, ||, a, 1, (||−1, a, ||, a, 1)) are executed. If the next alphabet symbol to the right is an a, then a new standard instruction is executed that is instantiated from the simple meta instruction (||−1, a, x, a, 0). If the memory address was pointing to the last a in aⁿ, then a new standard instruction is executed that is instantiated from the simple meta instruction (||−1, #, x, #, 0).

In this way, for each a on the memory to the right (higher memory addresses) of #a^m, the execution of the quantum random instruction (x, a, t, 0) determines whether each string a^m+k, satisfying 1≤k≤n−m, is in or not in (a₀ a₁ . . . a_n x)'s language.

After the execution of (||−1, #, x, #, 0), the memory address is pointing to a blank symbol, so the quantum random instruction (x, #, x, 0) is executed. If a 0 is measured by the quantum random source, the meta instructions (x, 0, v, #, 0, (||−1, #, n, #, 1)) and (v, #, n, #, 1, (||−1, a, ||, a, 1)) are executed. Then the last instruction executed is (n, #, h, N, 0) which indicates that aⁿ is not in (a₀ a₁ . . . a_n x)'s language.

If the execution of (x, #, x, 0) measures a 1, the meta instructions (x, 1, w, #, 0, (||−1, #, y, #, 1)) and (w, #, y, #, 1, (||−1, a, ||, a, 1)) are executed. Then the last instruction executed is (y, #, h, Y, 0) which indicates that aⁿ is in (a₀ a₁ . . . a_n x)'s language.

During the execution of the instructions, for each a on the memory to the right (higher memory addresses) of #a^m, ex-machine (a₀ a₁ . . . a_m x) evolves to (a₀ a₁ . . . a_n x) according to the specification in ex-machine 2, where one substitutes n for m. □

Remark 3.3.

When the binary string a₀ a₁ . . . a_m is presented as input, the ex-machine instructions for (a₀ a₁ . . . a_m x), specified in ex-machine 2, are constructible (i.e., can be printed) with a standard machine.

In contrast with lemma 3.1, (a₀ a₁ . . . a_m x)'s instructions are not executable with a standard machine when the input memory # #aⁱ# satisfies i>m because meta and quantum random instructions are required. Thus, remark 3.3 distinguishes the construction of (a₀ a₁ . . . a_m x)'s instructions from the execution of (a₀ a₁ . . . a_m x)'s instructions.

Proof.

When given a finite list (a₀ a₁ . . . a_m), where each a₁ is 0 or 1, the code listing below constructs (a₀ a₁ . . . a_m x)'s instructions. Starting with comment ;; Qx_builder.lsp, the code listing is expressed in a dialect of LISP, called newLISP. (See www.newlisp.org). LISP was designed, based on the lambda calculus, developed by Alonzo Church. The appendix of [33] outlines a proof that the lambda calculus is computationally equivalent to digital computer instructions (i.e., standard machine instructions). The following 3 instructions print the ex-machine instructions for (11010 x), listed in machine instructions 2.

(set ’a0_a1_dots_am (list 1 1 0 1 0) )
(set ’Qx_machine (build_Qx_machine a0_a1_dots_am) )
(print_xmachine Qx_machine) □
;; Qx_builder.lsp
(define (make_qr_instruction q_in a_in q_out move)
(list (string q_in) (string a_in) (string q_out) (string move)) )
;; Move is −1, 0 or 1
(define (make_instruction q_in a_in q_out a_out move)
(list (string q_in) (string a_in)
(string q_out) (string a_out) (string move)) )
(define (make_meta_instruction q_in a_in q_out a_out move_standard
r_in b_in r_out b_out move_meta)
(list (string q_in) (string a_in)
(string q_out) (string a_out) (string move_standard)
(make_instruction r_in b_in r_out b_out move_meta) ) )
(define (initial_Qx_machine)
(list
(make_instruction “0” “#” “8” “#” 1)
(make_instruction “8” “#” “x” “#” 0)
;; This means string a∧i is in the language.
(make_instruction “y” “#” “h” “Y ” 0)
;; This means string a∧i is NOT in the language.
(make_instruction “n” “#” “h” “N ” 0)
(make_qr_instruction “x” “#” “x ” 0)
(make_qr_instruction “x” “a” “t ” 0)
(make_meta_instruction “x” “0” “y” “#” 0 “|Q|-1” “#” “n” “#” 1)
(make_meta_instruction “x” “1” “w” “#” 0 “|Q|-1” “#” “y” “#” 1)
(make_meta_instruction “t” “0” “w” “a ” 0 “|Q|-1” “#” “n” “#” 1)
(make_meta_instruction “t” “1” “w” “a ” 0 “|Q|-1” “#” “y” “#” 1)
(make_meta_instruction “v” “#” “n” “#” 1 “|Q|-1” “a” “|Q|” “a” 1)
(make_meta_instruction “w” “#” “y” “#” 1 “|Q|-1” “a” “|Q|” “a” 1)
(make_meta_instruction “w” “a” “|Q|” “a” 1 “|Q|-1” “a” “|Q|” “a” 1)
(make_instruction “|Q|-1” “a” “x” “a” 0)
(make_instruction “|Q|-1” “#” “x” “#” 0)
))
(define (add_instruction instruction q_list)
(append q_list (list instruction) ) )
(define (check_a0_a1_dots_am a0_a1_dots_am)
(if (list? a0_a1_dots_am)
(dolist (a_i a0_a1_dots_am)
(if (member a_i (list 0 1) )
true
(begin
(println “ERROR! (build_Qx_machine
a0_a1_dots_am). a_i = ”a_i)
(exit)
)
)
a0_a1_dots_am )
nil
))
;;;;;;;;;;;;;;; BUILD MACHINE Q(a0 a1 . . . am x)
;; a0_a1_dots_am has to be a list of 0’s and 1’s or ’( )
(define (build_Qx_machine a0_a1_dots_am)
(let
( (Qx_machine (initial_Qx_machine))
(|Q| 8)
(b_|Q| nil)
(ins1 nil)
(ins2 nil)
)
(set ’check (check_a0_a1_dots_am a0_a1_dots_am) )
;; if nil OR check is an empty list, remove instruction (8, #, x, #, 0)
(if (or (not check) (empty? check) )
true
(set ’Qx_machine (append (list (Qx_machine 0))
(rest (rest Qx_machine))))
)
(if (list? a0_a1_dots_am)
(dolist (a_i a0_a1_dots_am)
(if ( = a_i 1)
(set ’b_ |Q| “y”)
(set ’b_ |Q| “n”) )
(set ’ins1 (make_instruction |Q| “#” b_|Q| “#” 1) )
(set ’Qx_machine (add_instruction ins1 Qx_machine) )
(set ’ins2 (make_instruction |Q| “a” (+ |Q| 1) “a” 1))
(set ’Qx_machine (add_instruction ins2 Qx_machine) )
(set ’|Q| (+ |Q| 1) )
)
)
Qx_machine
))
(define (print_elements instruction)
(let
( (idx_ub (min 4 (− (length instruction) 1)) ) (i 0) )
(for (i 0 idx_ub)
(print (instruction i) )
(if (< i idx_ub) (print “, ”))
)
))
(define (print_instruction instruction)
(print “(”)
(if ( <= (length instruction) 5)
(print_elements instruction)
(begin
(print_elements instruction)
(print “, (”)
(print_elements (instruction 5) )
(print “) ”) ) )
(printIn “) ”) )
(define (print_xmachine x_machine)
(printIn)
(dolist (instruction x_machine)
(print_instruction instruction))
(printIn)
)

Machine Specification 3.3.

Define as the union of (x) and all ex-machines (a₀ . . . a_mx) for each m∈ and for each a₀ . . . a_m in {0, 1}^m+1. In other words,

$=\left\{\left(x\right)\right\}\bigcup \stackrel{\infty }{\bigcup _{m=0}}\bigcup _{a_0\dots a_m\in {\left\{0,1\right\}}^{m+1}}\left\{\left(a_0{a}_1\dots a_{m}x\right)\right\}.$

Theorem 3.2.

Each language L_ƒ in can be computed by the evolving sequence of ex-machines (x), (ƒ(0) x), (ƒ(0)ƒ(1) x), . . . , (ƒ(0)ƒ(1) . . . ƒ(n) x), . . . .

Proof.

The theorem follows from ex-machine 1, ex-machine 2 and lemma 3.1. □

Machine Computation Property 3.3.

Given function ƒ:→{0, 1}, for any arbitrarily large n, the evolving sequence of ex-machines (ƒ(0)ƒ(1) . . . ƒ(n) x), (ƒ(0)ƒ(1) . . . ƒ(n)ƒ(n+1) x), . . . computes language L_ƒ.

Machine Computation Property 3.4.

Moreover, for each n, all ex-machines (x), (ƒ(0)x), (ƒ(0) ƒ(1) x), . . . , (ƒ(0)ƒ(1) . . . ƒ(n) x) combined have used only a finite amount of memory, finite number of states, finite number of instructions, finite number of executions of instructions and only a finite amount of quantum random information measured by the quantum random instructions.

Proof.

For each n, the finite use of computational resources follows immediately from remark 2, specification 7 and the specification of ex-machine 2. □

A set X is called countable if there exists a bijection between X and . Since the set of all Turing machines is countable and each Turing machine only recognizes a single language most (in the sense of Cantor's hierarchy of infinities) languages L_ƒ are not computable with a Turing machine. More precisely, the cardinality of the set of languages L_ƒ computable with a Turing machine is ₀, while the cardinality of the set of all languages is ₁.

For each non-negative integer n, define the language tree (a₀ a₁ . . . a_n) {L_ƒ:ƒ∈{0, 1 and ƒ(i) a_i, for i satisfying 0≤i≤n}. Define the corresponding subset of {0, 1 as (a₀ a₁ . . . a_n)={ƒ∈{0, 1:ƒ(i) a_i for i satisfying 0≤i≤n}. Let Ψ denote this 1-to-1 correspondence, where {0, 1 and (a₀ a₁ . . . a_n)(a₀ a₁ . . . a_n).

Since the two quantum random axioms 1 and 2 are satisfied, each finite path ƒ(0)ƒ(1) . . . ƒ(n) is equally likely and there are 2ⁿ⁺¹ of these paths. Thus, each path of length n+1 has probability 2⁻⁽ⁿ⁺¹⁾. These uniform probabilities on finite strings of the same length can be extended to the Lebesgue measure μ on probability space {0, 1. Hence each subset (a₀ a₁ . . . a_n) has measure 2⁻⁽ⁿ⁺¹⁾. That is, μ((a₀ a₁ . . . an))=2⁻⁽ⁿ⁺¹⁾ and μ({0, 1)=1. Via the Ψ correspondence between each language tree (a₀ a₁ . . . a_n) and subset (a₀ a₁ . . . a_n), uniform probability measure p induces a uniform probability measure ν on , where ν((a₀ a₁ . . . a_n))=2⁻⁽ⁿ⁺¹⁾ and ν()=1.

Theorem 3.5.

For Functions ƒ:→{0, 1}, the Probability that Language L_ƒ is Turing Incomputable has Measure 1 in (ν,).

Proof.

The Turing machines are countable and therefore the number of functions ƒ:→{0, 1} that are Turing computable is countable. Hence, via the Ψ correspondence, the Turing computable languages L_ƒ have measure 0 in . □

Moreover, the Martin-Löf random sequences ƒ:→{0, 1} have Lebesgue measure 1 in {0,1 and are a proper subset of the Turing incomputable sequences.

Machine Computation Property 3.6.

(x) is not a Turing machine. Each ex-machine (a₀ a₁ . . . a_m x) in is not a Turing machine.

Proof.

(x) can evolve to compute Turing incomputable languages on a set of probability measure 1 with respect to (ν,). Also, (a₀ a₁ . . . a_m x) can evolve to compute Turing incomputable languages on a set of measure 2^−(m+1) with respect to (ν,). In contrast, each Turing machine only recognizes a single language, which has measure 0. In fact, the measure of all Turing computable languages is 0 in . □

Remark 3.4.

The statements in theorem 3.5 and corollary 3.6 can be sharpened when deeper results are obtained for the quantum random source used by the quantum random instructions.

4 A Non-Deterministic Execution Machine

A brief, intuitive summary of a non-deterministic execution machine is provided first before the formal description in machine specification 4.1. Our non-deterministic execution machine should not be confused with the nondeterministic Turing machine that is described on pages 30 and 31 of [12].

Part of the motivation for our approach is that procedure 4 is easier to analyze and implement. Some embodiments of procedure 4 can be implemented using non-deterministic generator 142 in FIG. 23. In some embodiments, the non-deterministic generator 142 in FIG. 23 along with a source of photons shown in FIG. 24 and FIG. 25 can help implement procedure 4 with quantum random measurements 6730, shown in FIG. 67. Moreover, our non-deterministic execution machine can be emulated with an ex-machine.

In a standard digital computer, the computer program can be specified as a function; from a current machine configuration (q, k, T), where q is the machine state, k is the memory address being scanned and T is the memory, there is exactly one instruction to execute next or the Turing machine halts on this machine configuration.

Instead of a function, in embodiments of our invention(s) of a non-deterministic execution machine, the program is a relation. From a particular machine configuration, there is ambiguity on the next instruction I in to execute. This is computational advantage when the adversary does not know the purpose of the program . Measuring randomness with quantum random measurements 6730 in FIG. 67 helps select the next instruction to execute. In some embodiments, the quantum randomness is measured, using the non-deterministic hardware shown in FIGS. 23, 24, and 25.

Part of our non-deterministic execution machine specification is that each possible instruction has a likelihood of being executed. Some quantum randomness is measured with 6730 in FIG. 67 and the next instruction executed is selected according to this quantum measurement and each instruction's likelihood. In some embodiments, the quantum randomness is measured, using hardware that is designed according to the protocol in FIG. 70.

Before machine specifications are provided, some symbol definitions are reviewed. Symbol ⁺ is the positive integers. Recall that represents the rational numbers. [0, 1] is the closed interval of real numbers x such that 0≤x≤1. The expression x∉X means element x is NOT a member of X. For example,

$-1\notin \mathbb{N},\frac{3}{127}\in \mathrm{and}\frac{1+\sqrt{5}}{2}\notin .$ The symbol ∩ means intersection. Note

$\left\{-5,0,\frac{3}{127}\right\}\bigcap =\left\{-5,0,\frac{3}{127}\right\}\mathrm{and}\left\{-5,0,\frac{1+\sqrt{5}}{2},\pi \right\}\bigcap =\left\{-5,0\right\}.$

Machine Specification 4.1.

A Non-Deterministic Execution Machine

A non-deterministic machine is defined as follows:

• • Q is a finite set of states.
  • is a set of final states and
  • When machine execution begins, the machine is in an initial state q₀ and q₀∈Q.
  • is a finite set of alphabet symbols that are read from and written to memory.
  • # is a special alphabet symbol called the blank symbol that lies in .
  • The machine's memory T is represented as a function T:. The alphabet symbol stored in the kth memory cell is T(k).
  • is a next-instruction relation, which is a subset of Q××Q××{−1,0,+1}. acts as a non-deterministic program where the non-determinism arises from how an instruction is selected from before it is executed. Each instruction I that lies in the set specifies how machine executes a computational step. When machine is in state q and scanning alphabet symbol α=T(k) at memory cell (address) k, an instruction (such that the first two coordinates of I are q and α, respectively) is non-deterministically selected. If instruction I=(q, α, r, β, y) is selected, then instruction I is executed as follows:
    • Machine changes from machine state q to machine state r.
    • Machine replaces alphabet symbol α with alphabet symbol β so that T(k)=β. The rest of the memory remains unchanged.
    • If y=−1, then machine N starts scanning one memory cell downward in memory and is subsequently scanning the alphabet symbol T(k−1), stored in memory address k−1.
    • If y=+1, then machine N starts scanning one memory cell upward in memory and is subsequently scanning the alphabet symbol T(k+1), stored in memory address k+1.
    • If y=0, then machine continues to scan the same memory cell and subsequently is scanning alphabet symbol T(k)=β, stored in memory address k.
  • To assure is a physically realizable machine, before machine starts executing, there exist M>0 such that the memory contains only blank symbols (i.e., T(k)=#) in all memory addresses, satisfying |k|>M.
  • ={p₁, p₂, . . . , p_||} is a finite set of rational numbers, contained in ∩[0, 1], such that ||=||, where || is the number of instructions in .
  • ν:→ is a bijective function. Let I be an instruction in . The purpose of ν(I) is to help derive the likelihood of non-deterministically selecting instruction I as the next instruction to execute.

Non-deterministic machine 4.1 can be used to execute two different instances of a procedure with a different sequence of machine instructions 6700, as shown in FIG. 67.

Machine Specification 4.2.

Machine Configurations and Valid Computational Steps

A machine configuration _i is a triplet (q, k, T_i) where q is a machine state, k is an integer which is the current memory address being scanned and T_i represents the memory. Consider machine configuration _i+1=(r, l, T_i+1). Per machine specification 4.1, then is a valid computational step if instruction I=(q, α, r, β, y) in and memories T_i and T_i+1 satisfy the following four conditions:

• • 1. ν(I)>0.
  • 2. T_i(k)=α.
  • 3. T_i+1(k)=β and T_i+1(j)=T_i(j) for all j≠k.
  • 4. l=k+y.

Symbol ⁺ is the positive integers. Recall that represents the rational numbers. [0, 1] is the closed interval of real numbers x such that 0≤x≤1. The expression x∉X means element x is NOT a member of X. For example,

$-1\notin \mathbb{N},\frac{3}{127}\in \mathrm{and}\frac{1+\sqrt{5}}{2}\notin .$ The symbol ∩ means intersection. Note

$\left\{-5,0,\frac{3}{127}\right\}\bigcap =\left\{-5,0,\frac{3}{127}\right\}\mathrm{and}\left\{-5,0,\frac{1+\sqrt{5}}{2},\pi \right\}\bigcap =\left\{-5,0\right\}.$

The purpose of machine procedure 3 is to describe how a non-deterministic machine selects a machine instruction from the collection of machine instructions 6700 as shown in FIG. 67. This non-deterministic selection of the next instruction is based on the machine specification (i.e., function) v: and one or more quantum random measurements, executed by random instructions 6740. In our procedures, a line starting with ;; is a comment. Procedure 3 can be implemented as a computing system (FIG. 69) with standard instructions 6710, meta instructions 6720, and random instructions 6740, as shown in FIG. 67. Combining procedure 3 and recognizing that the other parts of machine specification 4.1 are contained in the standard, meta, and random instructions, non-deterministic, self-modifiable (e.g., ex-machine) computation can execute the non-deterministic execution machine in machine specification 4.1.

Machine Instructions 3.

; ; The instructions in   are indexed as {J1, J2, . . . , Jm}, where  .
set                      ⁢                                                                                          ⁢                      σ                                        =                                                                  ∑                                                  i                          =                          1                                                m                                            ⁢                                              v                        ⁡                                                  (                                                      J                            i                                                    )
; ; The interval [0, 1) is subdivided into subintervals with rational
endpoints.
set i = 1
set x = 0
set                      ⁢                                                                                          ⁢                                              δ                        i                                                              =                                                                  v                        ⁡                                                  (                                                      J                            1                                                    )                                                                    σ
while( i ≤ m )
{
set Li = [x, x + δi)
increment i
set⁢⁢δi=v⁡(Ji)σ
update x to x + δ
}
set                      ⁢                                                                                          ⁢                      δ                                        =                                                                  1                        2                                            ⁢                                                                                          ⁢                      min                      ⁢                                                                                          ⁢                                              {                                                                              δ                            1                                                    ,                                                      δ                            2                                                    ,                          …                          ⁢                                                                                                          ,                                                      δ                            m                                                                          }
compute n > 0 so that 2−n < δ
using a non-deterministic generator, sample n bits b1, b2, . . . , bn
set                    ⁢                                                                                  ⁢                                          x                      =                                                                        ∑                                                      i                            =                            1                                                    n                                                ⁢                                                                              b                            i                                                    ⁢                                                                                                          ⁢                                                      2                                                          -                              i
select instruction Jk such that x lies in interval Lk

In some embodiments, machine instructions (procedure) 4 can be implemented with standard instructions 6710, meta instructions 6720, and random instructions 6740, as shown in FIG. 67. Random instructions 6740 take quantum random measurements 6740, while executing. In some embodiments, quantum random measurements 6740 are measured according to protocol in FIG. 70. In other embodiments, random measurements 6740 are measured with non-deterministic generator 142, shown in FIG. 23.

In some embodiments, machine instructions non-deterministically selected may be represented in a C programming language syntax. In some embodiments, some of the instructions non-deterministically selected to execute have the C syntax such as x=1; or z=x*y;. In some embodiments, one of instructions selected may be a loop with a body of machine instructions such as:

for(i = 0; i < 100; i++)
{
. . . /* body of machine instructions, expressed in C. */
}

In some embodiments, a random instruction may measure a random bit, called random_bit and then non-deterministically execute according to the following code:

if (random_bit == 1)
C_function_1 ( );
else if (random_bit == 0)
C_function_2 ( );

In other embodiments, the machine instructions may have a programming language syntax such as JAVA, Go Haskell, C++, RISC machine instructions, JAVA virtual machine, Ruby, LISP

Machine Instructions 4.

; ; | | is the number of final states in   = {f1, f2, . . . ,  }.
; ; q0 is an initial machine state and q0 ∉
; ; The symbols s1, s2, . . .   are the final state scores.
; ; Final state score si tallies how many times final state fi is reached.
; ; ai is the alphabet symbol stored at memory address i before the
inner loop is entered.
; ; ϵ is the reliability threshold. ϵ ∈   such that 0 < ϵ < 1 and is
usually very small.
; ; r is the variable that stores the current reliability value.
for each q in
for each a in
{
store in   all instructions I in   ∩ (  ×   ×   ×  ×
{−1, 0, +1}) where instruction I's 1st coordinate is q, I's 2nd
coordinate is a and v(I) > 0
}
; ; Initialize each score to 0 before entering the outer loop.
set s1 = 0 set s2 = 0 . . . set    = 0
; ; Initialize n = c where c > 1. The procedure works independent of c.
set n =
set r = 1 + ϵ
while ( r ≥ ϵ)
{  ; ; When 0 ≤ i < m, T(i) = ai and T(k) = # whenever k < 0 or
k ≥ m.
store word a0a1 . . . am−1 in memory
start scanning memory address k = 0
initialize machine state q = q0
set j = 1
set⁢⁢r=1⌈log2⁡(n)⌉
set d = 1 ;; — d is the membership degree of the random
instructions selected.
set dmax = 0
while ( j ≤ n AND q ∉   )
{
Set a = T(k), where k is the current memory address bein scanned.
randomly select instruction Ij from   by executing procedure 3
Per definition 4.1 execute instruction Ij = (q, αj, rj, βj, y), which
updates state q = rj, writes βj in tape square k and moves tape head
location k to y + k.
set d equal to d * v(Ij)
if new machine state q is a final state fi
{
set⁢⁢σ=∑l=1⁢⁢sl⁢⁢set⁢⁢γi=siσ⁢⁢set⁢⁢κi=si+1σ+1⁢⁢set⁢⁢δi=κi-γi
if δi > r set r = δi
if d > dmax set dmax = d
increment score si
}
increment j
}
increment n
}

In machine instructions (procedure) 4, the ex-machine that implements the pseudocode executes a particular non-deterministic machine a finite number of times and if a final state is reached, the procedure increments the corresponding final state score. After the final state scores have been tallied such that they converge inside the reliability interval (0, ϵ), then the ex-machine execution is completed and the ex-machine halts.

Machine Instructions 5.

INPUT: Machine is in state q0 and the memory is initialized
to . . . ## a0a1 ... am−1 ## . . .
for each q in Q
for each a in
{
store in   all instructions I in   ∩
(Q ×   × Q ×   × {−1, 0, +1}) where
instruction I’s 1st coordinate is q, I’s 2nd coordinate
is a and v(I) > 0
}
;; Initialize n = N where N > 1.
set n = N
set l = 1
while ( l ≤ r)
{
;; When 0 ≤ i < m, T(i) = ai, and T(k) = #
whenever k < 0 or k ≥ m.
store word a0a1 ... am−1 in memory
start scanning memory address k = 0
initialize machine state q = q0
set j = 1
set d = 1 # d is the membership degree of the
random instructions selected.
set dmax = 0
while ( j ≤ n AND q ∉   )
{
Set a = T(k), where k is the current memory address
being scanned.
randomly select instruction Ij from   by
executing procedure 3.
Per specification 4.1 execute instruction Ij =
(q, αj, rj, βj, x), which updates state
q = rj, writes βj in tape square k and moves to
memory address k to x + k.
set d equal to d*v (Ij).
if new machine state q is final state ƒi
{
if d > dmax set dmax = d
}
increment j
}
increment l
}
OUTPUT: dmax

Machine instructions 5 is useful for executing a computational procedure so that each instance of the procedure executes a different sequence of instructions and in a different order. This unpredictability of the execution of instructions makes it difficult for an adversary to comprehend the computation. Machine instructions 5 can be executed with a finite sequence of standard, meta and random instructions as shown in FIG. 67.

In the following analysis, the likelihood of procedure (machine instructions) 4 finding the maximum is estimated.

Machine Computation Property 4.1.

For each x, let v_x=ν(I_x). Consider the acceptable computational path

$0_{}\stackrel{I_{j_1}}{\mapsto }{1}_{}\stackrel{I_{j_2}}{\mapsto }{2}_{}\dots {N-1}_{}\stackrel{I_{j_N}}{\mapsto }{N}_{}$ such that machine configuration _N is in final state q_ƒ and p=υ_j1*υ_j2* . . . *υ_jN is a maximum. The expected number of times that inner loop in procedure 5 executes acceptable path

$0_{}\stackrel{I_{j_1}}{\mapsto }{1}_{}\stackrel{I_{j_2}}{\mapsto }{2}_{}\dots {N-1}_{}\stackrel{I_{j_N}}{\mapsto }{N}_{}$ is 0 when n<N and at least rp when n≥N.

Proof.

When n<N, it is impossible for the inner loop to execute the path

$0_{}\stackrel{I_{j_1}}{\mapsto }{1}_{}\stackrel{I_{j_2}}{\mapsto }{2}_{}\dots {N-1}_{}\stackrel{I_{j_N}}{\mapsto }{N}_{},$ so the expected number of times is 0. When n=N, the independence of each random sample that selects instruction I_ji and the fact that

$0_{}\stackrel{I_{j_1}}{\mapsto }{1}_{}\stackrel{I_{j_2}}{\mapsto }{2}_{}\dots {N-1}_{}\stackrel{I_{j_N}}{\mapsto }{N}_{}$ is an acceptable path implies that the probability of executing this computational path is p=υ_j1*υ_j2* . . . *υ_jN. When n>N, the probability of executing this path is still p because the inner loop exits if the final state in M_N is reached. □

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 [33] and refers to a finite deterministic 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 deterministic machine is known, then the future behavior of the machine can be determined. There are quantum processes and other embodiments that measure quantum effects 6730 in FIG. 67 from photons (or other physically non-deterministic processes). One embodiment is shown in FIG. 23, FIG. 24 and FIG. 25. Quantum random measurements 6730 are used by random instructions 6740 in FIG. 67.

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 measure random events 6720 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 FIG. 24 and FIG. 25, and detected by the semiconductor device in FIG. 23, which are discussed further below.

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. In some embodiments, light emitting diode shown in FIG. 24 and FIG. 25 emits photons that make up a non-deterministic process. 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 [5, 6]—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.

FIG. 23 shows an embodiment of a non-deterministic process arising from quantum events i.e., the arrival and detection of photons. In an embodiment, the photons are emitted by some photonic energy source. In an embodiment, FIG. 24 shows an LED (light emitting diode) that emits photons. Arrival times of photons are quantum events. The non-deterministic generator 142 in FIG. 23 shows an example of an embodiment of a non-deterministic process, detecting quantum events. The mathematical expression hv refers to the energy of the photon that arrives where h is Planck's constant and v is the frequency of the photon. In an embodiment, three consecutive arrival times t₁<t₂<t₃ of three detected consecutive photons may be compared. If t₂−t₁>t₃−t₂, then non-deterministic generator 142 produces a 1 bit. If t₂−t₁<t₃−t₂, then non-deterministic generator 142 produces a 0 bit. In the special case that t₂−t₁=t₃−t₂, then no non-deterministic information is produced and three more arrival times are sampled by this non-deterministic process.

Non-Deterministic, Self-Modifiable Computation with an Active Element Machine

What are You Trying to Do? why is this Compelling?

Based upon the principles of Turing incomputability and connectedness and novel properties of the Active Element Machine, a malware-resistant computing machine is constructed. This novel computing machine is a non-Turing, non-register machine (non von-Neumann), called an active element machine (AEM). AEM programs are designed so that the purpose of the AEM computations are difficult to apprehend by an adversary and hijack with malware. As a method of protecting intellectual property, these methods can also be used to help thwart reverse engineering of proprietary algorithms, hardware design and other areas of intellectual property.

Limitations and Deficiencies of Prior Art

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.

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.

Malware Instructions (polymorphic variant)
	WVCTF:	mov	eax,	drl
		jmp	Loc1
	Loc2:	mov	edi,	[eax]
	LOWVCTF:	pop	ecx
		jecxz	SFMM
		inc	eax
		mov	esi,	ecx
		dec	eax
		nop
		mov	eax,	0d601h
		jmp	Loc3
	Loc1:	mov	ebx,	[eax + 10h]
		jmp	Loc2
	Loc3:	pop	edx
		pop	ecx
		nop
		call	edi
		jmp	LOWVCTF
	SFMM:	pop	ebx
		Pop	eax
		stc

From a deterministic machine (DM) perspective, only one output state r of one DM program, command η(q, a)=(r, b, x) needs to be changed to state m combined with additional hijacking DM commands adjoined to the original DM program. After visiting state m, these hijacking commands are executed, which enables the purpose of the original DM program to be hijacked.

Furthermore, once the digital computer program has been hijacked, if there is a friendly routine to check if the program is behaving properly, this safeguard routine will never get executed. As a consequence, the sequential execution of single instructions cripples the register machine program from defending and repairing itself. As an example of this fundamental security weakness of a digital computer, while some malware may have difficulty decrypting the computations of a homomorphic encryption operation, the malware can still hijack a register machine program computing homomorphic encryption operations and disable the program.

Brief Summary of Novelty and Advantages Over Prior Art

What is Novel about the Secure Active Element Machine?

A. A novel non-Turing computing machine—called the active element machine—is presented that has new capabilities. Turing machine, digital computer programs, register machine programs and standard neural networks have a finite prime directed edge complexity. (See definition 4.23.) A digital computer program or register machine program can be executed by a Turing or deterministic 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 or Deterministic register 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 deterministic 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.

Summary of AEM Methods

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 b₁ b₂ . . . b_m—accepts [b₁ b₂ . . . b_m] if active elements E₁, E₂ . . . , E_n 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].

Additional Detailed Description

Although various embodiments of the invention may have been motivated by various deficiencies with the prior art, which may be discussed or alluded to in one or more places in the specification, the embodiments of the invention do not necessarily address any of these deficiencies. In other words, different embodiments of the invention may address different deficiencies that may be discussed in the specification. Some embodiments may only partially address some deficiencies or just one deficiency that may be discussed in the specification, and some embodiments may not address any of these deficiencies.

Active Element Machine Description

An active element machine is composed of computational primitives called active elements. There are three kinds of active elements: Input, Computational and Output active elements. Input active elements receive information from the environment or another active element machine. This information received from the environment may be produced by a physical process, 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 E_i at the same time sum to a value greater than the threshold and E_i's refractory period has expired, then active element E_i fires. When an active element E_i 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={E_i:i∈Γ}; a collection of computational active elements E={E_i:i∈Ω}; and a collection of output active elements D={E_i:i∈Δ}.

Each computational and output active element, E_i, has the following components and properties.

• • A threshold θ_i
  • A refractory period r_i where r_i>0.
  • A collection of pulse amplitudes {A_ki:k∈Γ∪Ω}.
  • A collection of transmission times {τ_ki:k∈Γ∪Ω}, where τ_ki>0 for all k∈Γ∪Ω.
  • A function of time, Ψ_i(t), representing the time active element E_i last fired.

Ψ_i(t)=sup{s:s<t and g_i(s)=1}, where g_i(s) is the output function of active element E_i and is defined below. The sup is the least upper bound.

• • A binary output function, g_i(t), representing whether active element E_i fires at time t. The value of g_i(t)=1 if ΣA_ki(t)>θ_i where the sum ranges over all k∈Γ∪Ω and t≥Ψ_i(t)+r_i. In all other cases, g_i(t)=0. For example, g_i(t)=0, if t<Ψ_i(t)+r_i.
  • A set of firing times of active element E_k within active element E_i's integrating window, W_ki(t)={s: active element E_k fired at time s and 0≤t−s−τ_ki<ω_ki}. Let |W_ki(t)| denote the number of elements in the set W_ki(t). If W_ki(t)=Ø, then |W_ki(t)|=0.
  • A collection of input functions, {φ_ki:k∈Γ∪Ω}, each a function of time, and each representing pulses coming from computational active elements, and input active elements. The value of the input function is computed as φ_ki(t)=|W_ki(t)|A_ki(t).
  • The refractory periods, transmission times and pulse widths are positive integers; and pulse amplitudes and thresholds are integers. These parameters are a function of i.e. θ_i(t), r_i(t), A_ki(t), ω_ki(t), τ_ki(t). The time t is an element of the extended integers K.

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 E_i 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 E_i is not a computational active element, where i∈Δ−Ω, then E_i does not send pulses to active elements in this machine.

Some notions of the machine architecture are summarized. If g_i(s)=1, this means active element E_i fired at time s. The refractory period r_i is the amount of time that must elapse after active element E_i just fired before E_i can fire again. The transmission time τ_ki is the amount of time it takes for active element E_i to find out that active element E_k has fired. The pulse amplitude A_ki represents the strength of the pulse that active element E_k transmits to active element E_i after active element E_k has fired. After this pulse reaches E_i, the pulse width O)_ki represents how long the pulse lasts as input to active element E_i. At time s, the connection from E_k to E_i represents the triplet (A_ki (s), ω_ki(s), τ_ki(s)). If A_ki=0, then there is no connection from active element E_k to active element E_i.

Refractory Period

In an embodiment, each computational element and output element has a refractory period r_i, where r_i>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, r_i, is the amount of time that must elapse after active element E_i just fired and before active element E_i can fire again. In an alternative embodiment, refractory period r_i 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, {A_ki}_kεΓ∪Λ, where the first of the two indices k and i denote the active element from which the message associated with amplitude A_ki is sent, and the second index denotes the active element receiving the message. The amplitude, A_ki, represents the strength of the message that active element E_k transmits to active element E_i after active element E_k 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 A_ki. Similarly, each message may be associated with its own message width, {ω_ki}kεΓ∪Λ, sent from active element E_i to E_k, where ω_ki>0 for all kεΓ∪Λ. After a message reaches active E_i, the message width ω_ki represents how long the message lasts as input to active element E_i.

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, E_i, 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 α≤0 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 E_k to active element E_i. The transmission time, τ_ki, is the amount of time it takes for active element E_i to find out that active element E_k 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 E_i last fired. Mathematically, the function of time can be defined as ψ_i(t)=supremum {sεR:s<t AND g_i(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 E_k that are within active element E_i'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 E_i fired at least once, Ξ_ki(t) does not have any values (is an empty set) if the last time that active element E_i 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)|A_ki, because each time a message from active element E_k reaches active element E_i, 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, A_ki, therefore, the value Ø_ki(t) equals |Ξ_ki(t)|A_ki.

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, g_i(t), may represent whether the active element fires at time t. The function g_i(t) is given by

$g_i\left(t\right)=\{\begin{array}{ccc}1& \mathrm{if}\sum _{k\in \Gamma U\Lambda }{Ø}_{ki}\left(t\right)>{\theta }_i\mathrm{AND}t-{\psi }_i\left(t\right)\ge r_i& \\ 0& \mathrm{otherwise}& \end{array}.$

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, r_i, plus the time, ψ_i(t), that the active element last fired, then the active element E_i fires, and g_i(t)=1. If g_i(t₀)=1, then active element E_i fired at time t₀.

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 (A_ki, ω_ki, τ_ki). If A_ki=0, then there is no connection from active element E_k to active element E_i. If A_ki≠0, then there is a non-zero connection from active element E_k to active element E_i. In any given embodiment the active elements may have all of the above properties, only one of the above properties, or any combination of the above properties. In an embodiment, different active elements may have different combinations of the above properties. Alternatively, all of the active elements may have the same combination of the above properties.

Active Element Machine Programming Language

This section shows how to program an active element machine and how to change the machine architecture as program execution proceeds. It is helpful to define a programming language, influenced by S-expressions. There are five types of commands: Element, Connection, Fire, Program and Meta.

Syntax 1. AEM Program

In Backus-Naur form, an AEM program is defined as follows.

<AEM_program> ::= <cmd_sequence>
<cmd_sequence> ::= ″″ | <AEM_cmd><cmd_sequence> | <program_def><cmd_sequence>
<AEM_cmd> ::= <element_cmd> | <fire_cmd> | <meta_cmd> | <cnct_cmd> |
<program_cmd>
<ename> ::= ″″ | <int> | <symbol>
<symbol> ::= <symbol_string> | (<ename> . . . <ename>)
<symbol_string> ::= ″″ | <char_symbol><str_tail>
<str_tail> ::= ″″ | <char_symbol><str_tail> | 0<str_tail> | <pos_int><str_tail>
<char_symbol> ::= <letter> | <special_char>
<letter> ::= <lower_case> | <upper_case>
<lower_case> ::= a | b | c | d | e | f | g | h | i | j | k | l | m | n | o | p | q | r | s | t | u | v | w | x | y | z
<upper_case> ::= A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W |
X | Y | Z
<special_char> ::= ″″ | _

These rules represent the extended integers, addition and subtraction.

<int> ::= <pos_int> | <neg_int> | 0
<neg_int> ::= − <pos_int>
<pos_int> ::= <non_zero><digits>
<digits> ::= <numeral> | <numeral><digits>
<non_zero> ::= 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
<numeral> ::= ″″ | <non_zero> | 0
<aint> ::= <aint> <math_op> <d> | <d> <math_op> <aint> | <d>
<math_op> ::= + | −
<d> ::= <int> | <symbol_string> | <infinitesimal>
<infinitesimal> ::= dT

Element Command.

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

• • <element_cmd>::=(Element (Time <aint>) (Name <ename>) (Threshold <int>) (Refractory <pos_int>) (Last <int>))

The keyword Time indicates the time value s at which the element is created or updated. In some embodiments the time value s is an extended integer. If the name symbol value is E, the keyword Name tags the name E of the active element. The keyword Threshold tags the threshold θ_E(s) assigned to E. Refractory indicates the refractory value r_E(s). The keyword Last tags the last time fired value Ψ(s). Sometimes the time value, name value, threshold value, refractory value, or last time fired value are referred to as parameter values.

Below is an example of an element command.

• • (Element (Time 2) (Name H) (Threshold −3) (Refractory 2) (Last 0))

At time 2, if active element H does not exist, then it is created. Active element H has its threshold set to −3, its refractory period set to 2, and its last time fired set to 0. After time 2, active element H exists indefinitely with threshold=−3, refractory=2 until a new Element command whose name value H is executed at a later time; in this case, the Threshold, Refractory and Last values specified in the new command are updated.

Connection Command.

A Connection command creates or updates a connection from one active element to another active element. This command has the following Backus-Naur syntax.

• • <cnct_cmd>::=(Connection (Time <aint>) (From <ename>) (To <ename>) [(Amp <int>) (Width <pos_int>) (Delay <pos_int>)])

The keyword Time indicates the time value s at which the connection is created or updated. In some embodiments the time value s is an extended integer. The keyword From indicates the name F of the active element that sends a pulse with these updated values. The keyword To tags the name T of the active element that receives a pulse with these updated values. The keyword Amp indicates the pulse amplitude value Δ_FT(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 TFT(S). In some embodiments the transmission time T_FT(S) is an extended integer. Sometimes the time value, from name, to name, pulse amplitude value, pulse width value, or transmission time value are referred to as parameter values.

When the AEM clock reaches time s, F and T are name values that must be the name of an element that already has been created or updated before or at time s. Not all of the connection parameters need to be specified in a connection command. If the connection does not exist beforehand and the Width and Delay values are not specified appropriately, then the amplitude is set to zero and this zero connection has no effect on the AEM computation. Observe that the connection exists indefinitely with the same parameter values until a new connection is executed at a later time between From element F and To element T.

The following is an example of a connection command.

• • (Connection (Time 2) (From C) (To L) (Amp −7) (Width 1) (Delay 3))

At time 2, the connection from active element C to active element L has its amplitude set to −7, its pulse width set to 1, and its transmission time set to 3.

Fire Command.

The Fire command has the following Backus-Naur syntax.

• • <fire_cmd>::=(Fire (Time <aint>) (Name <ename>))

The Fire command fires the active element indicated by the Name tag at the time indicated by the Time tag. Sometimes the time value and name value are referred to as parameter values of the fire command. In some embodiments, the fire command is used to fire input active elements in order to communicate program input to the active element machine. An example is (Fire (Time 3) (Name C)), which fires active element C at t=3.

Program Command.

The Program command is convenient when a sequence of commands are used repeatedly. This command combines a sequence of commands into a single command. It has the following definition syntax.

• • <program_def>::=(Program <pname>[(Cmds <cmds>)] [(Args <args>)]
  • <cmd_sequence>)
  • <pname>=<ename>
  • <cmds>::<cmd_name>|<cmd_name><cmds>
  • <cmd_name>::=Element Connection|Fire|Meta|<pname>
  • <args>::=<symbol>|<symbol><args>

The Program command has the following execution syntax.

• • <program_cmd>::=(<pname>[(Cmds <cmds>)] [(Args <args_cmd>)])
  • <args_cmd>::=<ename>|<ename><args_cmd>

The FireN program is an example of definition syntax.

(Program FireN (Args t E)
(Element (Time 0) (Name E)(Refractory 1)(Threshold 1) (Last 0))
(Connection (Time 0) (From E) (To E)(Amp 2)(Width 1) (Delay 1))
(Fire (Time 1) (Name E))
(Connection (Time t+1) (From E) (To E) (Amp 0))
)

The execution of the command (FireN (Args 8 E1)) causes element E1 to fire 8 times at times 1, 2, 3, 4, 5, 6, 7, and 8 and then E1 stops firing at time=9.

Keywords clock and dT

The keyword clock evaluates to an integer, which is the current active element machine time. clock is an instance of <ename>. If the current AEM time is 5, then the command

• • (Element (Time clock) (Name clock) (Threshold 1) (Refractory 1) (Last −1))
  • is executed as
  • (Element (Time 5) (Name 5) (Threshold 1) (Refractory 1) (Last −1))

Once command (Element (Time clock) (Name clock) (Threshold 1) (Refractory 1) (Last −1)) is created, then at each time step this command is executed with the current time of the AEM. If this command is in the original AEM program before the clock starts at 0, then the following sequence of elements named 0, 1, 2, . . . will be created.

• • (Element (Time 0) (Name 0) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 1) (Name 1) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 2) (Name 2) (Threshold 1) (Refractory 1) (Last −1))
  • . . . .

The keyword dT represents a positive infinitesimal amount of time. If m and n are integers and 0≤m<n, then mdT<ndT. Furthermore, dT>0 and dT is less than every positive rational number. Similarly, −dT<0 and −dT is greater than every negative rational number. The purpose of dT is to prevent an inconsistency in the description of the machine architecture. For example, the use of dT helps remove the inconsistency of a To element about to receive a pulse from a From element at the same time that the connection is removed.

Meta command.

The Meta command causes a command to execute when an element fires within a window of time. This command has the following execution syntax.

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

To understand the behavior of the Meta command, consider the execution of

• • (Meta (Name E) (Window 1 w) (C (Args t a))

where E is the name of the active element. The keyword Window tags an interval i.e. a window of time. 1 is an integer, which locates one of the boundary points of the window of time. Usually, w is a positive integer, so the window of time is [l, l+w]. If w is a negative integer, then the window of time is [l+w, l].

The command C executes each time that E fires during the window of time, which is either [l, l+w] or [l+w, l], depending on the sign of w. If the window of time is omitted, then command C executes at any time that element E fires. In other words, effectively 1=−∞ and w=∞. Consider the example where the FireN command was defined before.

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

Command C is executed 6 times with arguments 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 E_i 's firing times in the interval of time W=[t₁, t₂]. Let s₁ be the earliest firing time of E_i lying in W, and s_n the latest firing time lying in W. Then E_i's firing sequence F(E_i, W)=[s₁, . . . , s_n]={s∈W:g_i(s)=1} is called a firing sequence of the active element E_i over the window of time W. From active elements {E_i, E₂, . . . , E₁} create the tuple (F(E_i, W), F(E₂, W), . . . , F(E_n, W)) which is called a firing pattern of the active elements {E_i, E₂, . . . , E.} 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 W₁, . . . , W₁ be a sequence of time intervals. Let F(E, W₁)=(F(E_i, W₁), F (E₂, W₁), . . . , F(E_n, W₁)) be a firing pattern of active elements E={E₁, . . . , E_n} over the interval W₁. In general, let F(E, W_k)=(F(E_i, W_k), F(E₂, W_k), . . . F(E_n, W_k)) be a firing pattern over the interval of time W_k. From these, a sequence of firing patterns, [F(E, W₁), F(E, W₂), . . . , F(E, W_n)] is created.

Machine Computation

Let [F(E, W₁), F(E, W₂), . . . , F(E, W_n)] be a sequence of firing patterns. [F(E, S₁), F(E, S₂), . . . , F(E, S_m)] 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, S₁), F(E, S₂), . . . , F(E, S_m)] and consequently M's output active elements O fire according to [F(E, W₁), F(E, W₂), . . . , F(E, W_n)]. In this case, the machine M computes [F(E, W₁), F(E, W₂), . . . , F(E, W_n)] from [F(E, S₁), F(E, S₂), . . . , F(E, S_m)].

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.

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

Then the simultaneous execution of these two commands can be handled by defining the outcome to be equivalent to the execution of only one connection command where the respective amplitudes, widths and transmission times are averaged.

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

In the general case, for n connection commands

• • (Connection (Time t) (From A) (To B) (Amp a1) (Width w1) (Delay s1))
  • (Connection (Time t) (From A) (To B) (Amp a2) (Width w2) (Delay s2))
  • . . .
  • (Connection (Time t) (From A) (To B) (Amp an)(Width wn)(Delay sn))
  • resolve these to the execution of one connection command
  • (Connection (Time t) (From A) (To B) (Amp a) (Width w) (Delay s))
  • where a, w and s are defined based on the application. These embodiments can be implemented in active element machine software, AEM hardware or a combination of AEM hardware and software.

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

• • a=(a1+a2+ . . . +an)/n
  • w=(w1+w2+ . . . +wn)/n
  • s=(s1+s2+ . . . +sn)/n

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

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

• • a=median(a1, a2, . . . , an)
  • w=median(w1, w2, . . . , wn)
  • s=median(s1, s2, . . . , sn)

Another alternative embodiment adds the parameter values.

• • a=a1+a2+ . . . +an
  • w=w1+w2+ . . . +wn
  • s=s1+s2+ . . . +sn

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

• • (Element (Time t) (Name E) (Threshold h1) (Refractory r1) (Last s1))
  • (Element (Time t) (Name E) (Threshold h2) (Refractory r2) (Last s2))
  • . . .
  • (Element (Time t) (Name E) (Threshold hn) (Refractory m) (Last sn))
  • resolve these to the execution of one element command,
  • (Element (Time t) (Name E) (Threshold h) (Refractory r) (Last s))
  • where h, r and s are defined based on the application. Similar to the connection command, for theoretical studies of the AEM, the threshold, refractory and last time fired values can be averaged.
  • h=(h1+h2+ . . . +hn)/n
  • r=(r1+r2+ . . . +rn)/n
  • s=(s1+s2+ . . . +sn)/n

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

• • h=median(h1, h2, . . . , hn)
  • r=median(r1, r2, . . . , rn)
  • s=median(s1, s2, . . . , sn)

Another alternative is to add the parameter values.

• • h=h1+h2+ . . . +hn
  • r=r1+r2+ . . . +rn
  • s=s1+s2+ . . . +sn

Rules A, B, and C resolve concurrencies pertaining to the Fire, Meta and Program commands. Rule A. If two or more Fire commands attempt to fire element E at time t, then element E is fired just once at time t.

Rule B. Only one Meta command can be triggered by the firing of an active element. If a new Meta command is created and it happens to be triggered by the same element E as a prior Meta command, then the old Meta command is removed and the new Meta command is triggered by element E.

Rule C. If a Program command is called by a Meta command, then the Program's internal Element, Connection, Fire and Meta commands follow the previous concurrency rules defined. If a Program command exists within a Program command, then these rules are followed recursively on the nested Program command.

An AEM Program Computes A Ramsey Number

This section shows how to compute a Ramsey number with an AEM program. Ramsey theory can be intuitively described as structure which is preserved under finite decomposition. Applications of Ramsey theory include computer science, including lower bounds for parallel sorting, game theory and information theory. Progress on determining the basic Ramsey numbers r(k, l) has been slow. For positive integers k and l, r(k, l) denotes the least integer n such that if the edges of the complete graph K_n are 2-colored with colors red and blue, then there always exists a complete subgraph K_k containing all red edges or there exists a subgraph Ki 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 K_N 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 K₆ 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 K₅ 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 K₅.

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 K₅, based on the group's purpose. This is useful because these groups will be used when describing the computation for K₆.

1. The elements representing red and blue edges are established as follows.

• • (Element (Time 0) (Name R_12) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name R_15) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name R_23) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name R_34) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name R_45) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name B_13) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name B_14) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name B_24) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name B_25) (Threshold 1) (Refractory 1) (Last −1))
  • (Element (Time 0) (Name B_35) (Threshold 1) (Refractory 1) (Last −1))

2. Fire element R_24 if edge {j, k} is red.

• • (Fire (Time 0) (Name R_12))
  • (Fire (Time 0) (Name R_15))
  • (Fire (Time 0) (Name R_23))
  • (Fire (Time 0) (Name R_34))
  • (Fire (Time 0) (Name R_45))

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

• • (Fire (Time 0) (Name B_13))
  • (Fire (Time 0) (Name B_14))
  • (Fire (Time 0) (Name B_24))
  • (Fire (Time 0) (Name B_25))
  • (Fire (Time 0) (Name B_35))

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

• • (Meta (Name R_jk) (Window 0 1)
  • (Connection (Time 0) (From R_jk) (To R_jk) (Amp 2) (Width 1) (Delay 1)))
  • (Meta (Name B_jk) (Window 0 1)
  • (Connection (Time 0) (From B_jk) (To B_jk) (Amp 2) (Width 1) (Delay 1)))

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

• • (Connection (Time 0) (From B_ij) (To B_ijk) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time 0) (From B_jk) (To B_ijk) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time 0) (From B_ik) (To B_ijk) (Amp 2) (Width 1) (Delay 1))

5. To determine if a red triangle exists on vertex set {i, j, k}, where {i, j, k} ranges

• • over T, three connections are created for each potential red triangle.
  • (Connection (Time 0) (From R_ij) (To R_ijk) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time 0) (From R_jk) (To R_ijk) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time 0) (From R_ik) (To R_ijk) (Amp 2) (Width 1) (Delay 1))

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

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

Because the threshold is 5, the element R_ijk only fires when all three elements R_ij, R_jk, R_ik fired one unit of time ago. Likewise, the element B_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

$\left|E\right|+2\left|T\right|=\frac{5!}{2!3!}+2\frac{5!}{3!2!}=30\mathrm{active}\mathrm{elements}.$ Further, this AEM program creates and uses 3|T|+3|T|+|E|=70 connections.

For K₆, 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,

$E=\frac{6!}{2!4!}$

To build a similar AEM program, the commands in groups 1 and 2 range over every possible 2-coloring of E. The remaining groups 3, 4, 5 and 6 are the same based on the AEM commands created in groups 1 and 2 for each particular 2-coloring.

This AEM program verifies that every 2-coloring of E contains at least one red triangle or one blue triangle i.e. N(3, 2, 2)=6. There are no optimizations using graph isomorphisms made here. If an AEM language construct is used for generating all active elements for each 2-coloring of E at time zero, then the resulting AEM program can determine the answer in 5 time steps. One more time step is needed, 215 additional connections and one additional element to verify that every one of the 215 AEM programs is indicating that it found a red or blue triangle. This AEM program—that determines the answer in 5 time steps—uses 2^|E|(|E|+2|T|)+1 active elements and 2^|E|(3|T|+3|T|+|E|+1) connections, where |E|=15 and |T|=20. Some graph problems are related to the computation of Ramsey numbers.

A couple common graph problems are the traveling salesman problem and the traveling purchaser problem. (See <http://en.wikipedia.org/wiki/Taveling_salesman_problem> and <http://en.wikipedia.org/wiki/Taveling_purchaser_problem>.)

The traveling salesman problem can be expressed as a list of cities and their pairwise distances. The solution of the problem consists of finding the shortest possible tour that visits each city exactly once. Methods of solving the traveling salesman problem are useful for FedEx and other shipping companies where fuel costs and other shipping costs are substantial.

The traveling salesman problem has applications in planning, logistics, and the manufacture of microchips. Slightly modified, the traveling salesman problem appears as a sub-problem in many areas, such as DNA sequencing. In these applications, the concept city represents, for example, customers, soldering points, or DNA fragments, and the concept distance represents travelling times or cost, or a similarity measure between DNA fragments.

In embodiments similar to the computation of Ramsey numbers, the cities (customers, soldering points or DAN fragments) correspond to active elements and there is one connection between two cities for a possible tour that is being explored. In some embodiments, the thresholds of the two elements are used to account for the distance between the cities while exploring a path for a shortest possible tour. In other embodiments, the different distances between cities can be accounted for by using time.

Multiplying Numbers with an Active Element Machine

This section shows how to multiply numbers with an active element machine. Elements Y0, Y1, Y2, Y3 denote a four bit number and elements Z0, Z1 Z2, Z3 denote a four bit number. The corresponding bit values are y₀, y₁, y₂, y₃ and z₀, z₁, z₂, z₃. The multiplication of y₃ y₂ y₁ y₀*z₃ z₂ z₁ z₀ is shown in Table 13. An active element program is constructed based on Table 13.

The following commands set up elements and connections to perform a four bit multiplication of y₃ y₂ y₁ y₀*z₃ z₂ z₁ z₀ where the result of this multiplication e₇ e₆ e₅ e₄ e₃ e₂ e₁ e₀ 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 y_j z_k where S_jk fires if and only if y_j=1 and z_k=1. The elements C_jk help determine the value of e_i represented by element E_i where j+k=i.

First, two useful program commands are defined.

(Program set_element (Args s xk theta r L)
(Element (Time s-2dT) (Name xk) (Threshold theta) (Refractory r) (Last L))
)
(Program set_connection (Args s f xk a w tau)
(Connection (Time s-dT) (From f) (To xk) (Amp a) (Width w) (Delay tau))
)

The firing activity of element E₀ expresses the value of e₀. The elements and connections for the product y₀ z₀ which determine the value of e₀ are determined by the following three program commands.

• • (set_element s E0 3 1 s−2)
  • (set_connection s Y0 E0 2 1 1)
  • (set_connection s Z0 E0 2 1 1)

Table 14 shows the amplitude and threshold used to compute the value of e₀. Table 15 shows the firing patterns for elements S₁₀ and S₀₁ representing the value of products y₁ z₀ and y₀ z₁. Table 16 shows the amplitudes from elements S₁₀ and S₀₁ to elements C₀₁ and C₁₁ and the thresholds of C₀₁ and C₁₁. Table 17 shows the amplitudes from elements C₀₁ and C₁₁ to element E₁ and the threshold of E₁. The firing activity of element E₁ expresses the value of e₁. Below are active element machine commands that express the parameter values of these elements and connections shown in table 14, table 15, table 16 and table 17.

• • (set_element s S_10 3 1 s−2)
  • (set_connection s Y1 S_10 2 1 1)
  • (set_connection s Z0 S_10 2 1 1)
  • (set_element s S_01 3 1 s−2)
  • (set_connection s Y0 S_01 2 1 1)
  • (set_connection s Z1 S_01 2 1 1)
  • (set_element s C_01 1 1 s−2)
  • (set_element s C_11 3 1 s−2)
  • (set_connection s S_10 C_01 2 1 1)
  • (set_connection s S_10 C_11 2 1 1)
  • (set_connection s S_01 C_01 2 1 1)
  • (set_connection s S_01 C_11 2 1 1)
  • (set_element s E1 1 1 s−2)
  • (set_connection s C_01 E1 2 1 1)
  • (set_connection s C_11 E1 −2 1 1)

Table 18 shows the firing patterns for elements S₂₀, S₁₁, S₀₂ and C₁₁. Table 19 shows the amplitudes from elements S₂₀, S₁₁ S₀₂, C₁₁ to elements C₀₂, C₁₂, C₂₂ C₃₂ and the thresholds of C₀₂, C₁₂, C₂₂ and C₃₂. Table 20 shows the amplitudes from elements C₀₂, C₁₂, C₂₂, C₃₂ to elements P₀₂, P₁₂, P₂₂ and the thresholds of elements P₀₂, P₁₂, P₂₂. Table 21 shows the amplitude and threshold used to compute the value of e₂. The firing activity of element E₂ expresses the value of e₂. Below are active element machine commands that express the parameter values of the elements and connections indicated in table 18, table 19, table 20 and table 21.

• • (set_element s S_20 3 1 s−2)
  • (set_connection s Y2 S_20 2 1 1)
  • (set_connection s Z0 S_20 2 1 1)
  • (set_element s S_11 3 1 s−2)
  • (set_connection s Y1 S_11 2 1 1)
  • (set_connection s Z1 S_11 2 1 1)
  • (set_element s S_02 3 1 s−2)
  • (set_connection s Y0 S_02 2 1 1)
  • (set_connection s Z2 S_02 2 1 1)
  • (set_element s C_02 1 1 s−2)
  • (set_element s C_12 3 1 s−2)
  • (set_element s C_22 5 1 s−2)
  • (set_element s C_32 7 1 s−2)
  • (set_connection s S_20 C_02 2 1 1)
  • (set_connection s S_20 C_12 2 1 1)
  • (set_connection s S_20 C_22 2 1 1)
  • (set_connection s S_20 C_32 2 1 1)
  • (set_connection s S_11 C_02 2 11)
  • (set_connection s S_11 C_12 2 1 1)
  • (set_connection s S_11 C_22 2 11)
  • (set_connection s S_11 C_32 2 11)
  • (set_connection s S_02 C_02 2 1 1)
  • (set_connection s S_02 C_12 2 1 1)
  • (set_connection s S_02 C_22 2 1 1)
  • (set_connection s S_02 C_32 2 1 1)
  • (set_connection s C_11 C_02 2 11)
  • (set_connection s C_11 C_12 2 1 1)
  • (set_connection s C_11 C_22 2 11)
  • (set_connection s C_11 C_32 2 11)
  • (set_element s P_02 1 1 s−2)
  • (set_element s P_12 1 1 s−2)
  • (set_element s P_22 7 1 s−2)
  • (set_connection s C_02 P_02 2 1 1)
  • (set_connection s C_02 P_12 0 1 1)
  • (set_connection s C_02 P_22 2 1 1)
  • (set_connection s C_12 P_02 −2 1 1)
  • (set_connection s C_12 P_12 2 1 1)
  • (set_connection s C_12 P_22 2 1 1)
  • (set_connection s C_22 P_02 2 1 1)
  • (set_connection s C_22 P_12 2 1 1)
  • (set_connection s C_22 P_22 2 1 1)
  • (set_connection s C_32 P_02 −2 1 1)
  • (set_connection s C_32 P_12 −4 1 1)
  • (set_connection s C_32 P_22 2 1 1)
  • (set_element s E2 1 1 s−2)
  • (set_connection s P_02 E2 2 1 1)

Table 22 shows the firing patterns for elements S₃₀, S₂₁, S₁₂, S₀₃, P₁₂ representing the value of products y₃ z₀, y₂ z₁, y₁ z₂ and y₀ z₃ and the carry value. Table 23 shows the amplitudes from elements S₃₀, S₂₁, S₁₂ and S₀₃ to elements C₀₃, C₁₃, C₂₃, C₃₃, and C₄₃. Table 24 shows the amplitudes from elements C₀₃, C₁₃, C₂₃, C₃₃, and C₄₃ to elements P₀₃, P₁₃, P₂₃ and the thresholds of elements P₀₃, P₁₃, P₂₃. Table 25 shows the amplitude and threshold used to compute the value of e₃. The firing activity of element E₃ expresses the value of e₃. Below are active element machine commands that express the parameter values shown in table 22, table 23, table 24 and table 25.

• • (set_element s S_30 3 1 s−2)
  • (set_connection s Y3 S_30 2 1 1)
  • (set_connection s Z0 S_30 2 1 1)
  • (set_element s S_21 3 1 s−2)
  • (set_connection s Y2 S_21 2 1 1)
  • (set_connection s Z1 S_21 2 1 1)
  • (set_element s S_12 3 1 s−2)
  • (set_connection s Y1 S_12 2 1 1)
  • (set_connection s Z2 S_12 2 1 1)
  • (set_element s S_03 3 1 s−2)
  • (set_connection s Y0 S_0321 1)
  • (set_connection s Z3 S_03 2 11)
  • (set_element s C_03 1 1 s−2)
  • (set_element s C_13 3 1 s−2)
  • (set_element s C_23 5 1 s−2)
  • (set_element s C_33 7 1 s−2)
  • (set_element s C_43 9 1 s−2)
  • (set_connection s S_30 C_03 2 1 1)
  • (set_connection s S_30 C_13 2 1 1)
  • (set_connection s S_30 C_23 2 1 1)
  • (set_connection s S_30 C_33 2 1 1)
  • (set_connection s S_30 C_43 2 1 1)
  • (set_connection s S_21 C_03 2 1 1)
  • (set_connection s S_21 C_13 2 1 1)
  • (set_connection s S_21 C_23 2 1 1)
  • (set_connection s S_21 C_33 2 1 1)
  • (set_connection s S_21 C_43 2 1 1)
  • (set_connection s S_12 C_03 2 1 1)
  • (set_connection s S_12 C_13 2 1 1)
  • (set_connection s S_12 C_23 2 1 1)
  • (set_connection s S_12 C_33 2 1 1)
  • (set_connection s S_12 C_43 2 1 1)
  • (set_connection s S_03 C_03 2 1 1)
  • (set_connection s S_03 C_13 2 1 1)
  • (set_connection s S_03 C_23 2 1 1)
  • (set_connection s S_03 C_33 2 1 1)
  • (set_connection s S_03 C_43 2 1 1)
  • (set_connection s P_12 C_03 2 1 1)
  • (set_connection s P_12 C_13 2 1 1)
  • (set_connection s P_12 C_23 2 1 1)
  • (set_connection s P_12 C_33 2 1 1)
  • (set_connection s P_12 C_43 2 1 1)
  • (set_element s P_03 1 1 s−2)
  • (set_element s P_13 1 1 s−2)
  • (set_element s P_23 7 1 s−2)
  • (set_connection s C_03 P_03 2 1 1)
  • (set_connection s C_03 P_13 0 1 1)
  • (set_connection s C_03 P_23 2 1 1)
  • (set_connection s C_13 P_03 −2 1 1)
  • (set_connection s C_13 P_13 2 1 1)
  • (set_connection s C_13 P_23 2 1 1)
  • (set_connection s C_23 P_03 2 1 1)
  • (set_connection s C_23 P_13 2 1 1)
  • (set_connection s C_23 P_23 2 1 1)
  • (set_connection s C_33 P_03 −2 1 1)
  • (set_connection s C_33 P_13 −4 1 1)
  • (set_connection s C_33 P_23 2 1 1)
  • (set_connection s C_43 P_03 2 1 1)
  • (set_connection s C_43 P_13 0 1 1)
  • (set_connection s C_43 P_23 2 1 1)
  • (set_element s E3 1 1 s−2)
  • (set_connection s P_03 E3 2 1 1)

Table 26 shows the firing patterns for elements S₃₁, S₂₂, S₁₃, P₁₃, P₂₂. Table 27 shows the amplitudes from elements S₃₁, S₂₂, S₁₃, P₁₃, P₂₂ to elements C₀₄, C₁₄, C₂₄, C₃₄, C₄₄ and the thresholds of C₀₄, C₁₄, C₂₄, C₃₄ and C₄₄. Table 28 shows the amplitudes from elements C₀₄, C₁₄, C₂₄, C₃₄, and C₄₄ to elements P₀₄, P₁₄, P₂₄ and the thresholds of elements P₀₄, P₁₄, P₂₄. Table 29 shows the amplitude and threshold used to compute the value of e₄. The firing activity of element E₄ expresses the value of e₄. Below are active element machine commands that express the parameter values shown in table 26, table 27, table 28 and table 29.

• • (set_element s S_31 3 1 s−2)
  • (set_connection s Y3 S_31 2 1 1)
  • (set_connection s Z1 S_31 2 1 1)
  • (set_element s S_22 3 1 s−2)
  • (set_connection s Y2 S_22 2 1 1)
  • (set_connection s Z2 S_22 2 1 1)
  • (set_element s S_13 3 1 s−2)
  • (set_connection s Y1 S_13 2 1 1)
  • (set_connection s Z2 S_13 2 1 1)
  • (set_element s C_04 1 1 s−2)
  • (set_element s C_14 3 1 s−2)
  • (set_element s C_24 5 1 s−2)
  • (set_element s C_34 7 1 s−2)
  • (set_element s C_44 9 1 s−2)
  • (set_connection s S_31 C_04 2 1 1)
  • (set_connection s S_31 C_14 2 1 1)
  • (set_connection s S_31 C_24 2 1 1)
  • (set_connection s S_31 C_34 2 1 1)
  • (set_connection s S_31 C_44 2 1 1)
  • (set_connection s S_22 C_04 2 1 1)
  • (set_connection s S_22 C_14 2 1 1)
  • (set_connection s S_22 C_24 2 1 1)
  • (set_connection s S_22 C_34 2 1 1)
  • (set_connection s S_22 C_44 2 1 1)
  • (set_connection s S_13 C_04 2 1 1)
  • (set_connection s S_13 C_14 2 1 1)
  • (set_connection s S_13 C_24 2 1 1)
  • (set_connection s S_13 C_34 2 1 1)
  • (set_connection s S_13 C_44 2 1 1)
  • (set_connection s P_22 C_04 2 1 1)
  • (set_connection s P_22 C_14 2 1 1)
  • (set_connection s P_22 C_24 2 1 1)
  • (set_connection s P_22 C_34 2 1 1)
  • (set_connection s P_22 C_44 2 1 1)
  • (set_connection s P_13 C_04 2 1 1)
  • (set_connection s P_13 C_14 2 1 1)
  • (set_connection s P_13 C_24 2 1 1)
  • (set_connection s P_13 C_34 2 1 1)
  • (set_connection s P_13 C_44 2 1 1)
  • (set_element s P_04 1 1 s−2)
  • (set_element s P_14 1 1 s−2)
  • (set_element s P_24 7 1 s−2)
  • (set_connection s C_04 P_04 2 1 1)
  • (set_connection s C_04 P_14 0 1 1)
  • (set_connection s C_04 P_24 2 1 1)
  • (set_connection s C_14 P_04 −2 1 1)
  • (set_connection s C_14 P_14 2 1 1)
  • (set_connection s C_14 P_24 2 1 1)
  • (set_connection s C_24 P_04 2 1 1)
  • (set_connection s C_24 P_14 2 1 1)
  • (set_connection s C_24 P_24 2 1 1)
  • (set_connection s C_34 P_04 −2 1 1)
  • (set_connection s C_34 P_14 −4 1 1)
  • (set_connection s C_34 P_24 2 1 1)
  • (set_connection s C_44 P_04 2 1 1)
  • (set_connection s C_44 P_14 0 1 1)
  • (set_connection s C_44 P_24 2 1 1)
  • (set_element s E4 1 1 s−2)
  • (set_connection s P_04 E4 2 1 1)

Table 30 shows the firing patterns for elements S₃₂, S₂₃, P₁₄, P₂₃. Table 31 shows the amplitudes from elements S₃₂, S₂₃, P₁₄, P₂₃ to elements C₀₅, C₁₅, C₂₅, C₃₅ and the thresholds of C₀₅, C₁₅, C₂₅, C₃₅. Table 32 shows the amplitudes from elements C₀₅, C₁₅, C₂₅, C₃₅ to elements P₀₅, P₁₅, P₂₅ and the thresholds of elements P₀₅, P₁₅, P₂₅. Table 33 shows the amplitude and threshold used to compute the value of e₅. The firing activity of element E₅ expresses the value of e₅. Below are active element machine commands that express the parameter values shown in table 30, table 31, table 32 and table 33.

• • (set_element s S_32 3 1 s−2)
  • (set_connection s Y3 S_32 2 1 1)
  • (set_connection s Z2 S_32 2 1 1)
  • (set_element s S_23 3 1 s−2)
  • (set_connection s Y2 S_23 2 1 1)
  • (set_connection s Z3 S_23 2 1 1)
  • (set_element s C_05 1 1 s−2)
  • (set_element s C_15 3 1 s−2)
  • (set_element s C_25 5 1 s−2)
  • (set_element s C_35 7 1 s−2)
  • (set_connection s S_32 C_05 2 1 1)
  • (set_connection s S_32 C_15 2 1 1)
  • (set_connection s S_32 C_25 2 1 1)
  • (set_connection s S_32 C_35 2 1 1)
  • (set_connection s S_23 C_05 2 1 1)
  • (set_connection s S_23 C_15 2 1 1)
  • (set_connection s S_23 C_25 2 1 1)
  • (set_connection s S_23 C_35 2 1 1)
  • (set_connection s P_14 C_05 2 1 1)
  • (set_connection s P_14 C_15 2 1 1)
  • (set_connection s P_14 C_25 2 1 1)
  • (set_connection s P_14 C_35 2 1 1)
  • (set_connection s P_23 C_05 2 1 1)
  • (set_connection s P_23 C_15 2 1 1)
  • (set_connection s P_23 C_25 2 1 1)
  • (set_connection s P_23 C_35 2 1 1)
  • (set_element s P_05 1 1 s−2)
  • (set_element s P_15 1 1 s−2)
  • (set_element s P_25 7 1 s−2)
  • (set_connection s C_05 P_05 2 1 1)
  • (set_connection s C_05 P_15 0 1 1)
  • (set_connection s C_05 P_25 2 1 1)
  • (set_connection s C_15 P_05 −2 1 1)
  • (set_connection s C_15 P_15 2 1 1)
  • (set_connection s C_15 P_25 2 1 1)
  • (set_connection s C_25 P_05 2 1 1)
  • (set_connection s C_25 P_15 2 1 1)
  • (set_connection s C_25 P_25 2 1 1)
  • (set_connection s C_35 P_05 −2 1 1)
  • (set_connection s C_35 P_15 −4 1 1)
  • (set_connection s C_35 P_25 2 1 1)
  • (set_element s E5 1 1 s−2)
  • (set_connection s P_05 E5 2 1 1)

Table 34 shows the firing patterns for elements S₃₃, P₁₅, P₂₄. Table 35 shows the amplitudes from elements S₃₃, P₁₅, P₂₄ to elements C₀₆, C₁₆, C₂₆ and the thresholds of C₀₆, C₁₆, C₂₆. Table 36 shows the amplitudes from elements C₀₆, C₁₆, C₂₆ to elements P₀₆, P₁₆ and the thresholds of elements P₀₆, P₁₆. Table 37 shows the amplitude of the connection from element P₀₆ to element E6 and the threshold of E6. The firing activity of E6 expresses the value of e₆. Below are active element machine commands that express the parameter values shown in table 34, table 35, table 36 and table 37.

• • (set_element s S_33 3 1 s−2)
  • (set_connection s Y3 S_33 2 1 1)
  • (set_connection s Z3 S_33 2 1 1)
  • (set_element s C_06 1 1 s−2)
  • (set_element s C_16 3 1 s−2)
  • (set_element s C_26 5 1 s−2)
  • (set_connection s S_33 C_06 2 1 1)
  • (set_connection s S_33 C_16 2 1 1)
  • (set_connection s S_33 C_26 2 1 1)
  • (set_connection s P_15 C_06 2 1 1)
  • (set_connection s P_15 C_16 2 1 1)
  • (set_connection s P_15 C_26 2 1 1)
  • (set_connection s P_24 C_06 2 1 1)
  • (set_connection s P_24 C_16 2 1 1)
  • (set_connection s P_24 C_26 2 1 1)
  • (set_element s P_06 1 1 s−2)
  • (set_element s P_16 1 1 s−2)
  • (set_connection s C_06 P_06 2 1 1)
  • (set_connection s C_06 P_16 0 1 1)
  • (set_connection s C_16 P_06 −2 11)
  • (set_connection s C_16 P_16 2 11)
  • (set_connection s C_26 P_06 2 11)
  • (set_connection s C_26 P_16 2 11)
  • (set_element s E6 1 1 s−2)
  • (set_connection s P_06 E6 2 1 1)

The firing activity of element E7 represents bit e₇. When element P₁₆ is firing, this means that there is a carry so E7 should fire. The following commands accomplish this.

• • (set_element s E7 1 1 s−2)
  • (set_connection s P_16 E7 2 1 1)

Table 38 shows how the active element machine commands were designed to compute 1110*0111. Suppose that the AEM commands from the previous sections are called with s=2. Then y₀=0. y₁=1. y₂=1. y₃=1. z₀=

• • 1. z₁=1. z₂=1. z₃=0. Thus, fire input elements Y₁, Y₂ and Y₃ at time
  • 2. Similarly, fire input elements Z₀, Z₁ and Z₂ at time 2.
  • (set_element 2 Y1 1 1 0)
  • (set connection 2Y1 Y1 2 1+dT 1)
  • (fire (Time 2) (Name Y1))
  • (set_element 2 Y2 1 1 0)
  • (set_connection 2 Y2 Y2 2 1+dT 1)
  • (fire (Time 2) (Name Y2))
  • (set_element 2 Y3 1 1 0)
  • (set_connection 2Y3 Y3 2 1+dT 1)
  • (fire (Time 2) (Name Y3))
  • (set_element 2 Z0 1 1 0)
  • (set_connection 2 Z0 Z0 2 1+dT 1)
  • (fire (Time 2) (Name Z0))
  • (set_element 2 Z1 1 1 0)
  • (set_connection 2 Z1 Z1 2 1+dT 1)
  • (fire (Time 2) (Name Z1))
  • (set_element 2 Z2 1 1 0)
  • (set_connection 2 Z2 Z2 2 1+dT 1)
  • (fire (Time 2) (Name Z2))

Element E₀ never fires because E₀ only receives a pulse of amplitude 2 from Z₀ and has threshold 3. The fact that E₀ never fires represents that e₀=0.

In regard to the value of e₁, element S₁₀ fires at time 3 because Y₁ and Z₀ fire at time 2 and S₁₀ has a threshold of 3 and receives a pulse of amplitude 2 from Y₁ and Z₀. The following commands set these values.

• • (set_element s S_10 3 1 s−2)
  • (set_connection s Y1 S_10 2 1 1)
  • (set_connection s Z0 S_10 2 1 1)

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

• • (set_element s C_01 1 1 s−2)
  • (set_connection s S_10 C_01 2 1 1)
  • The commands
  • (set_element s E1 1 1 s−2)
  • (set_connection s C_01 E1 2 1 1)

cause E₁ to fire at time 5 and E₁ continues to fire indefinitely because the input elements Y₁, Y₂, Y₃, Z₀, Z₁ and Z₂ continue to fire at time steps 3, 4, 5, 6, 7, 8, . . . . The firing of element E₁ indicates that e₁=1.

In regard to the value of e₂, since elements Y₁ and Z₁ fire at time 2, element S₁₁ fires at time 3. Since elements Y₂ and Z₀ fire at time 2, element S₂₀ also fires at time 3. From the following commands

• • (set_element 2 C_02 1 1 0)
  • (set_element 2 C_12 3 1 0)
  • (set_connection 2 S_20 C_02 2 1 1)
  • (set_connection 2 S_20 C_12 2 1 1)
  • (set_connection 2 S_11 C_02 2 1 1)
  • (set_connection 2 S_11 C_12 2 1 1)
  • then elements C₀₂ and C₁₂ fire at time 4.
  • Element P₁₂ fires at time 5 because of the commands
  • (set_element 2 P_12 1 1 0)
  • (set_connection 2 C_12 P_12 2 1 1)
  • (set_connection 2 C_02 P_12 0 1 1)

Observe that element P₀₂ does not fire because C₁₂ sends a pulse with amplitude −2 and C₀₂ sends a pulse with amplitude 2 and element P₀₂ has threshold 1 as a consequence of command (set_element 2 P_02 1 1 0).

Since P₀₂ does not fire, element E2 does not fire as it threshold is 1 and the only connection to element E₂ is from P₀₂: (set_connection 2 P_02 E2 2 1 1). Since element E₂ does not fire, this indicates that e₂=0.

In regard to the value of e₃, since elements Y₃ and Z₀ fire at time 2, element S₃₀ fires at time 3. Since elements Y₂ and Z₁ fire at time 2, element S₂₁ fires at time 3. Since elements Y₁ and Z₂ fire at time 2, element S₁₂ fires at time 3. S₀₃ does not fire. From the following commands

• • (set_element 2 C_03 1 1 0)
  • (set_element 2 C_13 3 1 0)
  • (set_element 2 C_23 5 1 0)
  • (set_element 2 C_33 7 1 0)
  • (set_connection 2 S_30 C_03 2 1 1)
  • (set_connection 2 S_30 C_13 2 1 1)
  • (set_connection 2 S_30 C_23 2 1 1)
  • (set_connection 2 S_30 C_33 2 11)
  • (set_connection 2 S_21 C_03 2 11)
  • (set_connection 2 S_21 C_13 2 11)
  • (set_connection 2 S_21 C_23 2 11)
  • (set_connection 2 S_21 C_33 2 11)
  • (set_connection 2 S_12 C_03 2 1 1)
  • (set_connection 2 S_12 C_13 2 1 1)
  • (set_connection 2 S_12 C_23 2 1 1)
  • (set_connection 2 S_12 C_33 2 11)
  • (set_connection 2 P_12 C_03 2 11)
  • (set_connection 2 P_12 C_13 2 11)
  • (set_connection 2 P_12 C_23 2 11)
  • (set_connection 2 P_12 C_33 2 11)

then elements C₀₃, C₁₃, C₂₃ fire at time 4 and they will continue to fire every time step 5, 6, 7, 8 . . . because the elements Y₁, Y₂, Y₃, Z₀, Z₁ and Z₂ continue to fire at time steps 3, 4, 5, 6, 7, 8, . . . .

As a result of P₁₂ firing at time 5, C₃₃ fires at time 6, so at time 7, only P₂₃ fires. As a result, the long term behavior (after time step 7) of P₀₃ does not fire. Thus, E₃ does not fire after time step 7, which indicates that e₃=0.

Similar to that of element E₃, in the long term element E₄ does not fire, which indicates that e₄=0. Similarly, in the long term element E₅ fires, which indicates that e₅=1. Similarly, in the long term element E₆ fires, which indicates that e₆=1. Similarly, in the long term element E7 does not fire, which indicates that e₇=0.

As a consequence, multiplication of 1110*0111 equals 1100010 in binary, which represents that 14*7=98 in base 10. This active element program can execute any multiplication of two four bit binary numbers. Similar to the multiplication just described, tables 39, 40 and 41 show the multiplication steps for 11*9=99; 15*14=210; and 15*15=225.

AEM Firing Patterns Execute a Digital Computer Program

In some embodiments, an AEM using randomness 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 memory contents of the universal deterministic machine, 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 (FIGS. 24 and 25) and detected by a semiconductor chip that is a photodetector (FIG. 23). In some embodiments, the arrival times of photons act as the quantum events that help generate a random sequence of 0's and 1's. The procedure is used to help execute the same computation with multiple interpretations. In some embodiments, this same computation is a program instruction executed at two different instances.

Procedure 1. Randomness generates an AEM, representing a real number in 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 b₀ b₁ b₂ . . . of real number x lying in the interval [0, 1]. If input element I fires at time t=n, then b₁=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 b_n=0 and active element n is created so that it never fires. The following finite active element machine program exhibits this behavior.

• • (Program C (Args t)
  • (Connection (Time t) (From I) (To t) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time t+1+dT) (From I) (To t) (Amp 0))
  • (Connection (Time t) (From t) (To t) (Amp 2) (Width 1) (Delay 1)))
  • (Element (Time clock) (Name clock)
  • (Threshold 1) (Refractory 1) (Last −1))
  • (Meta (Name I) (C (Args clock)))

Suppose a sequence of random bits—obtained from the environment or from a 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.

• • (Element (Time 0) (Name 0) (Threshold 1) (Refractory 1) (Last −1))
  • (C (Args 0))

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

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

Because of the first connection command

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

the firing of input element I at time 0 sends a pulse with amplitude 2 to element 0. Thus, element 0 fires at time 1. Then at time 1+dT, a moment after time 1, the connection from input element I to element 0 is removed. At time 0, a connection from element 0 to itself with amplitude 2 is created. As a result, element 0 continues to fire indefinitely, representing that b₀=1. At time 1, command

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

is created. Since element 1 has no connections into it and threshold 1, element 1 never fires.

Thus b₁=0. At time 2, input element I fires, so the following commands are executed.

• • (Element (Time 2) (Name 2) (Threshold 1) (Refractory 1) (Last −1))
  • (C (Args 2))

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

• • (Connection (Time 2) (From I) (To 2) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time 3+dT) (From I) (To 2) (Amp 0))
  • (Connection (Time 2) (From 2) (To 2) (Amp 2) (Width 1) (Delay 1))

Because of the first connection command

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

the firing of input element I at time 2 sends a pulse with amplitude 2 to element 2. Thus, element 2 fires at time 3. Then at time 3+dT, a moment after time 3, the connection from input element I to element 2 is removed. At time 2, a connection from element 2 to itself with amplitude 2 is created. As a result, element 2 continues to fire indefinitely, representing that b₂=1.

Active Element Machine Firing Patterns

During a window of time, firing patterns can be put in 1-to-1 correspondence with the boolean functions ƒ: {0, 1}ⁿ→{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 X₀, X₁, X₂ and X₃ during window of time W=[a, b]. The refractory periods of X₀, X₁, X₂ and X₃ are chosen so that each X_k either fires or doesn't fire during window W. Thus, there are sixteen distinct firing patterns. Five of these firing patterns are shown in FIGS. 1, 2, 3, 4, and 5.

A one-to-one correspondence is constructed with the sixteen boolean functions of the form ƒ: {0, 1}×{0, 1}→{0, 1}. These boolean functions comprise the binary operators: and ∧, or ∨, 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}ⁿ→{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 X₀, X₁, X₂ and X₃. (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 {X₀, X₁, . . . , X−1} that determine the firing pattern during the window of time W. Then |(X_k, W)|=the number of times that element X_k fired during window of time W. Thus, define the number of firings during window W as

$\left(X,W\right)=\sum _{k=0}^{n-1}\left(X_k,W\right).$ Observe that |(X, W)|=0 for firing pattern 0000 shown in FIG. 1 and |(X, W)|=2 for firing pattern 0011. To isolate a firing pattern so that element P only fires if this unique firing pattern occurs, set the threshold of element P=2|(X, W)|−1.

The element command for P is:

• • (Element (Time a−dT) (Name P) (Threshold 2|(X, W)|−1) (Refractory b−a) (Last 2a−b)) Further, if element X_k doesn't fire during window of time W, then set the amplitude of the connection from X_k to P to −2. If element X_k does fire during window of time W, then set the amplitude of the connection from X_k to P equal to 2. For each element X_k, the pulse width is set to |W|=b−a. Each connection from X_k to P is based on whether X_k is supposed to fire or is not supposed to fire during W. If X_k is supposed to fire during W, then the following connection is established.
  • (Connection (Time a−dT) (From X_k) (To P) (Amp 2) (Width b−a) (Delay 1))

If X_k is not supposed to fire during W, then the following connection is established.

• • (Connection (Time a−dT) (From X_k) (To P) (Amp −2) (Width b−a) (Delay 1))

The firing pattern is already known because it is determined based on a random source of bits received by input elements, as discussed in procedure 1. Consequently, −2|(X, W)| is already known. How an active element circuit is designed to create a firing pattern that computes the appropriate boolean function is discussed in the following example.

Example. Computing ⊕ (Exclusive-OR) with Firing Pattern 0010

Consider firing pattern 0010. In other words, X₂ fires but the other elements do not fire. The AEM is supposed to compute the boolean function exclusive-or A⊕B=(A∨B)∧(¬A∨¬B). The goal here is to design an AEM circuit such that A⊕B=1 if and only if the firing pattern for X₀, X₁, X₂, X₃ 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 X₀, X₁, X₂, X₃.

• • (Connection (Time a−2) (From A) (To X_0) (Amp 2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_0) (Amp 2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_0) (Threshold 3) (Refractory b−a) (Last 2a−b))
  • (Connection (Time a−2) (From A) (To X_1) (Amp −2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_1) (Amp −2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_1) (Threshold −1) (Refractory b−a) (Last 2a−b))
  • (Connection (Time a−2) (From A) (To X_2) (Amp 2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_2) (Amp 2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_2) (Threshold 1) (Refractory b−a) (Last 2a−b))
  • (Connection (Time a−2) (From A) (To X_3) (Amp 2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_3) (Amp 2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_3) (Threshold 3) (Refractory b−a) (Last 2a−b))

There are four cases for A⊕B: 1⊕0, 0⊕1, 1⊕1 and 0⊕0. In regard to this, choose the refractory periods so that A and B either fire or don't fire at t=0. Recall that W=[a, b]. In this example, assume a=2 and b=3. Thus, all refractory periods of X₀, X₁, X₂, X₃ 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 X₀ receives a pulse from A with amplitude 2 at time t=2. Element X₁ doesn't fire because its threshold=3. Element X₁ receives a pulse from A with amplitude −2 at time t=2. Element X₁ doesn't fire during W because X₁ has threshold=−1. Element X₂ receives a pulse from A with amplitude 2. Element X₂ fires at time t=2 because its threshold is 1. Element X₃ receives a pulse from A with amplitude 2 but doesn't fire during window W because X₃ has threshold=3.

Case 2. Element X₀ receives a pulse from B with amplitude 2 at time t=2. Element X₀ doesn't fire because its threshold=3. Element X₁ receives a pulse from B with amplitude −2 at time t=2. Element X₁ doesn't fire during W because X₁ has threshold=−1. Element X₂ receives a pulse from B with amplitude 2. Element X₂ fires at time t=2 because its threshold is 1. Element X₃ receives a pulse from B with amplitude 2, but doesn't fire during window W because X₃ has threshold=3.

Case 3. Element A fires at time t=0 and element B fires at t=0. Element X₀ receives two pulses from A and B each with amplitude 2 at time t=2. Element X₀ fires because its threshold=3. Element X₁ receives two pulses from A and B each with amplitude −2 at time t=2. Element X₁ doesn't fire during W because X₁ has threshold=−1. Element X₂ receives two pulses from A and B each with amplitude 2. Element X₂ fires at time t=2 because its threshold is 1. Element X₃ receives two pulses from A and B each with amplitude 2. Element X₃ fires at time t=2 because X₃ 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 X₀, X₂ and X₃ do not fire because they have positive thresholds. Element X₁ fires at t=2 because it has threshold=−1.

For the desired firing pattern 0010, the threshold of P=2|(X, W)|−1=1.

Below is the element command for P.

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

Below are the connection commands for making P fire if and only if firing pattern 0010 occurs during W.

• • (Connection (Time 2−dT) (From X_0) (To P) (Amp −2) (Width 1) (Delay 1))
  • (Connection (Time 2−dT) (From X_1) (To P) (Amp −2) (Width 1) (Delay 1))
  • (Connection (Time 2−dT) (From X_2) (To P) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time 2−dT) (From X_3) (To P) (Amp −2) (Width 1) (Delay 1))

For cases 1 and 2 (i.e., 1⊕0 and 0⊕1) only X₂ fires. A moment before X₂ fires at t=2 (i.e., −dT), the amplitude from X₂ to P is set to 2. At time t=2, a pulse with amplitude 2 is sent from X₂ to P, so P fires at time t=3 since its threshold=1. In other words, 100=1 or 001=1 has been computed. For case 3, (1⊕1), X₀, X₂ and X₃ fire. Thus, two pulses each with amplitude=−2 are sent from X₀ and X₃ to P. And one pulse with amplitude 2 is sent from X₂ to P. Thus, P doesn't fire. In other words, 101=0 has been computed. For case 4, (0⊕0), X₁ fires. One pulse with amplitude=−2 is sent to X₂. 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 X_k, separate these members based on the (amplitude from A to X_k, amplitude from B to X_k, threshold of X_k, element X_k) quadruplet. For example, the quadruplet (0, 2, 1, X₁) separates {(1, 1), (0, 1)} from {(1, 0), (0, 0)} with respect to X₁. Recall that A=1 means A fires and B=1 means B fires. Then X₁ will fire with inputs {(1, 1), (0, 1)} and X₁ will not fire with inputs {(1, 0), (0, 0)}. The separation rule is expressed as

$\left(0,2,1,X_1\right)\leftrightarrow \frac{\left\{\left(1,1\right),\left(0,1\right)\right\}}{\left\{\left(1,0\right),\left(0,0\right)\right\}}.$ Similarly,

$\left(0,-2,-1,X_2\right)\leftrightarrow \frac{\left\{\left(1,0\right),\left(0,0\right)\right\}}{\left\{\left(1,1\right),\left(0,1\right)\right\}}$ indicates that X₂ has threshold −1 and amplitudes 0 and −2 from A and B respectively. Further, X₂ will fire with inputs {(1, 0), (0, 0)} and will not fire with inputs {(1, 1), (0, 1)}.

Table 1 shows how to compute all sixteen boolean functions ƒ_k:{0, 1}×{0, 1}→{0, 1}. For each X, use one of 14 separation rules to map the level set ƒ_k⁻¹{1} or alternatively map the level set ƒ_k⁻¹{0} to one of the sixteen firing patterns represented by X₀, X₁, X₂ and X₃. The level set method works as follows.

Suppose the nand boolean function ƒ₁₃=−(A∧B) is to be computed with the firing pattern 0101. Observe that ƒ₁₃⁻¹{1}={(1, 0), (0, 1), (0, 0)}. Thus, the separation rules

$\left(2,2,3,X_k\right)\leftrightarrow \frac{\left\{\left(1,1\right)\right\}}{\left\{\left(1,0\right),\left(0,1\right),\left(0,0\right)\right\}}$ for k in {0, 2} work because X₀ and X₂ fire if and only if A fires and B fires. Similarly,

$\left(-2,-2,-3,X_j\right)\leftrightarrow \frac{\left\{\left(1,0\right),\left(0,1\right),\left(0,0\right)\right\}}{\left\{\left(1,1\right)\right\}}$ for j in {1, 3} work because X₁ and X₃ don't fire if and only if A fires and B fires. These rules generate the commands.

• • (Connection (Time a−2) (From A) (To X_0) (Amp 2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_0) (Amp 2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_0) (Threshold 3) (Refractory b−a) (Last 2a−b))
  • (Connection (Time a−2) (From A) (To X_1) (Amp −2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_1) (Amp −2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_1) (Threshold −3) (Refractory b−a) (Last 2a−b))
  • (Connection (Time a−2) (From A) (To X_2) (Amp 2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_2) (Amp 2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_2) (Threshold 3) (Refractory b−a) (Last 2a−b))
  • (Connection (Time a−2) (From A) (To X_3) (Amp −2) (Width b−a+1) (Delay 2))
  • (Connection (Time a−2) (From B) (To X_3) (Amp −2) (Width b−a+1) (Delay 2))
  • (Element (Time a−2) (Name X_3) (Threshold −3) (Refractory b−a) (Last 2a−b))

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

• • (Element (Time 2−dT) (Name P) (Threshold 3) (Refractory 1) (Last 1))
  • (Connection (Time 2−dT) (From X_0) (To P) (Amp −2) (Width 1) (Delay 1))
  • (Connection (Time 2−dT) (From X_1) (To P) (Amp 2) (Width 1) (Delay 1))
  • (Connection (Time 2−dT) (From X_2) (To P) (Amp −2) (Width 1) (Delay 1))
  • (Connection (Time 2−dT) (From X_3) (To P) (Amp 2) (Width 1) (Delay 1))

Case 1: ¬(0∧0). A doesn't fire and B doesn't fire. Thus, no pulses reach X₁ and X₃, who each have threshold −3. Thus, X₁ and X₃ fire. Similarly, no pulses reach X₀ and X₂, who each have threshold 3. Thus, the firing pattern 0101 shown in table 10 causes P to fire because element X₁ and X₃ each send a pulse with amplitude 2 to P which has threshold 3. 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 X₀ and X₂, who each have threshold 3. Thus, X₀ and X₂ don't fire. Similarly, one pulse from A with amplitude −2 reaches X₁ and X₃, who each have threshold −3. Thus, the firing pattern 0101 shown in table 11 causes P to fire because element X₁ and X₃ each send a pulse with amplitude 2 to P which has threshold 3. Therefore, ¬(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 X₀ and X₂, who each have threshold 3. Thus, X₀ and X₂ don't fire. Similarly, one pulse from B with amplitude −2 reaches X₁ and X₃, who each have threshold −3. Thus, the firing pattern 0101 shown in table 12 causes P to fire because element X₁ and X₃ each send a pulse with amplitude 2 to P which has threshold 3. Therefore, ¬(0∧1)=1 is computed.

Case 4: ¬(1∧1). A fires and B fires. Thus, two pulses each with amplitude 2 reach X₀ and X₂, who each have threshold 3. Thus, X₀ and X₂ fire. Similarly, two pulses each with amplitude −2 reach X₁ and X₃, who each have threshold −3. As a result, X₁ and X₃ don't fire. Thus, the firing pattern 1010 shown in table 13 prevents P from firing because X₀ and X₂ each send a pulse with amplitude −2 to P which has threshold 3. Therefore, ¬(1∧1)=0 is computed.

Overall, any one of the sixteen boolean functions in table 1 are uniquely mapped to one of the sixteen firing patterns by an appropriate AEM program. These mappings can be chosen arbitrarily: as a consequence, each register machine instruction can be executed at different times using distinct AEM firing patterns.

Executing a Digital Computer with Random Firing Patterns

A universal Deterministic Machine (UDM) is a deterministic machine that can execute the computation of any deterministic Machine by reading the other deterministic machine's description and input from the UDM's tape. Table 2 shows Minsky's universal deterministic machine described in [24]. This means that this universal deterministic machine can execute any program that a digital computer, or distributed system of computers, or a von Neumann machine can execute.

The elements of {0, 1}² are denoted as {00, 01, 10, 11}. Create a one-to-one correspondence between the memory symbols in the alphabet of the universal deterministic machine and the elements in {0, 1}² as follows: 0↔00, 1↔01, y↔10 and A↔11. Furthermore, consider the following correspondence of the states with the elements of {0, 1}3: q₁↔001, q₂↔010, q₃↔011, q₄↔100, q₅↔101, q₆↔110, q₇↔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 deterministic machine program i shown in table 3. Since the universal deterministic machine can execute any digital computer program, this demonstrates how to execute any digital computer program with a secure active element machine.

Following the methods in the previous section, multiple AEM firing interpretations are created that compute η. When the universal deterministic 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 UDM. The two boolean variables Y, Z represent the current memory symbol being read. From table 3, observe that η=(η₀ η₁ η₂, η₃ η₄, η₅). For each k such that 0≤k≤5, the level sets of the function η_k:{0, 1}³×{0, 1}²→{0, 1} are shown below.

• • η₀⁻¹(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)}
  • η₀⁻¹(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)}
  • η₁⁻¹(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)}
  • η₁⁻¹(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)}
  • η₂⁻¹(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)}
  • η₂⁻¹(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)}
  • η₃⁻¹(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)}
  • η₃⁻¹(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)}
  • η₃⁻¹(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)}
  • η₄⁻¹(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)}
  • η₅⁻¹(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)}
  • η₅⁻¹(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 η₅⁻¹(UWX, YZ){h}={(011, 00)} is the special case when the universal deterministic 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 UDM.

Copy Program.

This active element program copies active element a's firing state to element b.

(Program copy (Args s t b a)
(Element (Time s-1) (Name b) (Threshold 1) (Refractory 1) (Last s-1))
(Connection (Time s-1)(From a) (To b)(Amp 0) (Width 0) (Delay 1))
(Connection (Time s) (From a) (To b) (Amp 2) (Width 1) (Delay 1))
(Connection (Time s) (From b) (To b) (Amp 2) (Width 1) (Delay 1))
(Connection (Time t) (From a) (To b) (Amp 0) (Width 0) (Delay 1))
)

When the copy program is called, active element b fires if a fired during the window of time [s, t). Further, a connection is set up from b to b so that b will keep firing indefinitely. This enables b to store active element a's firing state. The following procedure describes the computation of the deterministic program η with random firing interpretations.

Procedure 2. Computing Deterministic Program η with Random Firing Patterns Consider function η₃: {0, 1}⁵→{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 η₃; if active element U doesn't fire during window W, then this corresponds to input U=0 in η₃. When U fires, W doesn't fire, X fires, Y doesn't fire and Z doesn't fire, this corresponds to computing η₃ (101, 00). The value 1=η₃(101, 00) is the underlined bit in (011, 10, 0), which is located in row 101, column 00 of table 3. Procedure 1 and the separation rules in table 7 are synthesized so that η₃ is computed using random active element firing patterns. In other words, the boolean function η₃ can be computed using an active element machine's dynamic interpretation. The dynamic part of the interpretation is determined by the random bits received from a quantum source. The firing activity of active element P₃ represents the value of η₃ (UWX, YZ). Fourteen random bits are read from a quantum random generator—for example, see [5]. These random bits are used to create a corresponding random firing pattern of active elements R₀, R₁, . . . R₁₃. Meta commands dynamically build active elements and connections based on the separation rules in table 7 and the firing activity of elements R₀, R₁, . . . R₁₃. These dynamically created active elements and connections determine the firing activity of active element P₃ based on the firing activity of active elements U, W, X, Y and Z. The details of this procedure are described below.

Read fourteen random bits a₀, a₁, . . . and a₁₃ from a quantum source. The values of these random bits are stored in active elements R₀, R₁, . . . R₁₃. If random bit a_k=1, then R_k fires; if random bit a_k=0, then R_k doesn't fire.

Set up dynamical connections from active elements U, X, W, Y, Z to elements D₀, D₁, . . . D₁₃. These connections are based on Meta commands that use the firing pattern from elements R₀, R₁, . . . R₁₃.

(Program set_dynamic_C (Args s t f xk a w tau rk)
(Connection (Time s-dT) (From f) (To xk) (Amp -a) (Width w) (Delay tau))
(Meta (Name rk) (Window s t) (Connection (Time t) (From f) (To xk) (Amp a) (Width w)
(Delay tau)))
)
(Program set_dynamic_E (Args s t xk theta r L rk)
(Element (Time s-2dT) (Name xk) (Threshold -theta) (Refractory r) (Last L))
(Meta (Name rk) (Window s t) (Element (Time t) (Name xk) (Threshold theta) (Refractory r)
(Last L)))
)

For D₀, follow the first row of separation table 7, reading the amplitudes from U, W, X, Y, Z to D₀ and the threshold for D₀. Observe that at time s−dT program set_dynamic_C initializes the amplitudes of the connections to A_U,D0=−2, A_W,D0=−2, A_X,D0=−2, A_Y,D0=2, A_Z,D0=2 as if R₀ doesn't fire. If R₀ does fire, then the Meta command in set_dynamic_C dynamically flips the sign of each of these amplitudes: at time t, the amplitudes are flipped to A_U,D0=2, A_W,D0=2, A_X,D0=2, A_Y,D0=−2, A_Z,D0=−2.

Similarly, the meta command in set_dynamic_E initializes the threshold of D₀ to θ_D0=−5 as if R₀ doesn't not fire. If R₀ does fire the meta command flips the sign of the threshold of D₀; for the D₀ case, the meta command sets θ_D0=5.

• • (set_dynamic_E s t D0 5 1 s−2 R0)
  • (set_dynamic_C s t U D0 2 1 1 R0)
  • (set_dynamic_C s t W D0 2 1 1 R0)
  • (set_dynamic_C s t X D0 2 1 1 R0)
  • (set_dynamic_C s t Y D0 −2 1 1 R0)
  • (set_dynamic_C s t Z D0 −2 1 1 R0)

Similarly, for elements D₁, . . . , D₁₃, the commands set_dynamic_E and set_dynamic_C dynamically set the element parameters and the connections from U, X, W, Y, Z to D₁, . . . , D₁₃ based on the rest of the quantum random firing pattern R₁, . . . , R₁₃.

• • (set_dynamic_E s t D1 3 1 s−2 R1)
  • (set_dynamic_C s t U D1 2 1 R1)
  • (set_dynamic_C s t W D1 2 1 R1)
  • (set_dynamic_C s t X D1 −2 1 R1)
  • (set_dynamic_C s t Y D1 −2 1 1 R1)
  • (set_dynamic_C s t Z D1 −2 1 1 R1)
  • (set_dynamic_E s t D2 5 1 s−2 R2)
  • (set_dynamic_C s t U D2 2 1 1 R2)
  • (set_dynamic_C s t W D2 2 1 1 R2)
  • (set_dynamic_C s t X D2 −2 1 1 R2)
  • (set_dynamic_C s t Y D2 −2 1 1 R2)
  • (set_dynamic_C s t Z D2 2 1 1 R2)
  • (set_dynamic_E s t D3 5 1 s−2 R3)
  • (set_dynamic_C s t U D3 2 1 1 R3)
  • (set_dynamic_C s t W D3 2 1 1 R3)
  • (set_dynamic_C s t X D3 −2 1 1 R3)
  • (set_dynamic_C s t Y D3 2 1 1 R3)
  • (set_dynamic_C s t Z D3 −2 1 1 R3)
  • (set_dynamic_E s t D4 3 1 s−2 R4)
  • (set_dynamic_C s t U D4 2 1 1 R4)
  • (set_dynamic_C s t W D4 −2 1 1 R4)
  • (set_dynamic_C s t X D4 2 1 1 R4)
  • (set_dynamic_C s t Y D4 −2 1 1 R4)
  • (set_dynamic_C s t Z D4 −2 1 1 R4)
  • (set_dynamic_E s t D5 5 1 s−2 R5)
  • (set_dynamic_C s t U D5 2 1 R5)
  • (set_dynamic_C s t W D5 −2 1 1 R5)
  • (set_dynamic_C s t X D5 2 1 R5)
  • (set_dynamic_C s t Y D5 −2 1 1 R5)
  • (set_dynamic_C s t Z D5 2 1 1 R5)
  • (set_dynamic_E s t D6 5 1 s−2 R6)
  • (set_dynamic_C s t U D6 2 1 1 R6)
  • (set_dynamic_C s t W D6 −2 1 1 R6)
  • (set_dynamic_C s t X D6 2 1 1 R6)
  • (set_dynamic_C s t Y D6 2 1 1 R6)
  • (set_dynamic_C s t Z D6 −2 1 1 R6)
  • (set_dynamic_E s t D7 11 s−2 R7)
  • (set_dynamic_C s t U D7 2 1 1 R7)
  • (set_dynamic_C s t W D7 −2 1 1 R7)
  • (set_dynamic_C s t X D7 −2 1 1 R7)
  • (set_dynamic_C s t Y D7 −2 1 1 R7)
  • (set_dynamic_C s t Z D7 −2 1 1 R7)
  • (set_dynamic_E s t D8 3 1 s−2 R8)
  • (set_dynamic_C s t U D8 2 1 1 R8)
  • (set_dynamic_C s t W D8 −2 1 1 R8)
  • (set_dynamic_C s t X D8 −2 1 1 R8)
  • (set_dynamic_C s t Y D8 2 1 1 R8)
  • (set_dynamic_C s t Z D8 −2 1 1 R8)
  • (set_dynamic_E s t D9 5 1 s−2 R9)
  • (set_dynamic_C s t U D9 −2 1 1 R9)
  • (set_dynamic_C s t W D9 2 1 1 R9)
  • (set_dynamic_C s t X D9 2 1 1 R9)
  • (set_dynamic_C s t Y D9 −2 1 1 R9)
  • (set_dynamic_C s t Z D9 2 1 1 R9)
  • (set_dynamic_E s t D10 5 1 s−2 R10)
  • (set_dynamic_C s t U D10 −2 1 1 R10)
  • (set_dynamic_C s t W D10 2 1 R10)
  • (set_dynamic_C s t X D10 2 1 1 R10)
  • (set_dynamic_C s t Y D10 2 1 R10)
  • (set_dynamic_C s t Z D10 −2 1 1 R10)
  • (set_dynamic_E s t D11 1 1 s−2 R11)
  • (set_dynamic_C s t U D11 −2 1 R11)
  • (set_dynamic_C s t W D11 2 1 R11)
  • (set_dynamic_C s t X D11 −2 1 R11)
  • (set_dynamic_C s t Y D11 −2 1 1 R11)
  • (set_dynamic_C s t Z D11 −2 1 1 R11)
  • (set_dynamic_E s t D12 3 1 s−2 R12)
  • (set_dynamic_C s t U D12 −2 1 1 R12)
  • (set_dynamic_C s t W D12 2 1 1 R12)
  • (set_dynamic_C s t X D12 −2 1 1 R12)
  • (set_dynamic_C s t Y D12 −2 1 1 R12)
  • (set_dynamic_C s t Z D12 2 1 1 R12)
  • (set_dynamic_E s t D13 5 1 s−2 R13)
  • (set_dynamic_C s t U D13 −2 1 1 R13)
  • (set_dynamic_C s t W D13 2 1 1 R13)
  • (set_dynamic_C s t X D13 −2 1 1 R13)
  • (set_dynamic_C s t Y D13 2 1 1 R13)
  • (set_dynamic_C s t Z D13 2 1 1 R13)

Set up connections to active elements G₀, G₁, G₂, . . . G₁₄ which represent the number of elements in {R₀, R₁, R₂, . . . R₁₃} that are firing. If 0 are firing, then only G₀ is firing. Otherwise, if k>0 elements in {R₀, R₁, R₂, . . . R₁₃} are firing, then only G₁, G₂, . . . G_k are firing.

(Program firing_count (Args G a b theta)
(Element (Time a-2dT) (Name G) (Threshold theta) (Refractory b-a) (Last 2a-b))
(Connection (Time a-dT) (From R0) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R1) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R2) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R3) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R4) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R5) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R6) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R7) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R8) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R9) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R10) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R11) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R12) (To G) (Amp 2) (Width b-a) (Delay 1))
(Connection (Time a-dT) (From R13) (To G) (Amp 2) (Width b-a) (Delay 1))
)
(firing_count G0 a b -1)
(firing_count G1 a b 1)
(firing_count G2 a b 3)
(firing_count G3 a b 5)
(firing_count G4 a b 7)
(firing_count G5 a b 9)
(firing_count G6 a b 11)
(firing_count G7 a b 13)
(firing_count G8 a b 15)
(firing_count G9 a b 17)
(firing_count G10 a b 19)
(firing_count G11 a b 21)
(firing_count G12 a b 23)
(firing_count G13 a b 25)
(firing_count G14 a b 27)

P₃ is the output of η₃. Initialize element P₃'s threshold based on meta commands that use the information from elements G₀, G₁, . . . G₁₃. Observe that t+dT<t+2 dT< . . . <t+15 dT so the infinitesimal dT and the meta commands set the threshold P₃ to −2(14−k)+1 where k is the number of firings. For example, if nine of the randomly chosen bits are high, then G₉ will fire, so the threshold of P₃ is set to −9. If five of the random bits are high, then the threshold of P₃ is set to −17. Each element of the level set creates a firing pattern of D₀, D₁, . . . D₁₃ equal to the complement of the random firing pattern R₀, R₁, . . . R₁₃ (i.e., D_k fires if and only if R_k does not fire).

(Program set_P_threshold (Args G P s t a b theta kdT)
(Meta (Name G) (Window s t)
(Element (Time t+kdT) (Name P) (Threshold theta) (Refractory b-a) (Last t-b+a))
)
(set_P_threshold G0 P3 s t a b -27 dT)
(set_P_threshold G1 P3 s t a b -25 2dT)
(set_P_threshold G2 P3 s t a b -23 3dT)
(set_P_threshold G3 P3 s t a b -21 4dT)
(set_P_threshold G4 P3 s t a b -19 5dT)
(set_P_threshold G5 P3 s t a b -17 6dT)
(set_P_threshold G6 P3 s t a b -15 7dT)
(set_P_threshold G7 P3 s t a b -13 8dT)
(set_P_threshold G8 P3 s t a b -11 9dT)
(set_P_threshold G9 P3 s t a b -9 10dT)
(set_P_threshold G10 P3 s t a b -7 11dT)
(set_P_threshold G11 P3 s t a b -5 12dT)
(set_P_threshold G12 P3 s t a b -3 13dT)
(set_P_threshold G13 P3 s t a b -1 14dT)
(set_P_threshold G14 P3 s t a b 1 15dT)

Set up dynamical connections from D₀, D₁, . . . D₁₃ to P₃ based on the random bits stored by R₀, R₁, . . . R₁₃. These connections are based on meta commands that use the firing pattern from elements R₀, R₁, . . . R₁₃.

(Program set_from_Xk_to_Pj (Args s t Xk Pj amp w tau Rk)
(Connection (Time s-dT) (From Xk) (To Pj) (Amp -amp) (Width w) (Delay tau))
(Meta (Name Rk) (Window s t)
(Connection (Time t) (From Xk) (To Pj) (Amp amp) (Width w) (Delay tau))
)
(set_from_Xk_to_Pj s t D0 P3 2 b-a 1 R0)
(set_from_Xk_to_Pj s t D1 P3 2 b-a 1 R1)
(set_from_Xk_to_Pj s t D2 P3 2 b-a 1 R2)
(set_from_Xk_to_Pj s t D3 P3 2 b-a 1 R3)
(set_from_Xk_to_Pj s t D4 P3 2 b-a 1 R4)
(set_from_Xk_to_Pj s t D5 P3 2 b-a 1 R5)
(set_from_Xk_to_Pj s t D6 P3 2 b-a 1 R6)
(set_from_Xk_to_Pj s t D7 P3 2 b-a 1 R7)
(set_from_Xk_to_Pj s t D8 P3 2 b-a 1 R8)
(set_from_Xk_to_Pj s t D9 P3 2 b-a 1 R9)
(set_from_Xk_to_Pj s t D10 P3 2 b-a 1 R10)
(set_from_Xk_to_Pj s t D11 P3 2 b-a 1 R11)
(set_from_Xk_to_Pj s t D12 P3 2 b-a 1 R12)
(set_from_Xk_to_Pj s t D13 P3 2 b-a 1 R13)

Similar procedures use random firing patterns on active elements {A₀, A₁, . . . A₁₄}, {B₀, B₁, . . . B₁₅}, {C₀, C₁, . . . C₁₄}, {E₀, E₁, . . . E₁₂}, and {F₀, F₁, . . . F₁₃} to compute η₀, η₁, η₂, η₄ and η₅, respectively. The outputs of η₀, η₁, η₂, η₄ and η₅ are represented by active elements P₀, P₁, P₂, P₄ and P₅, respectively. The level set rules for η₀, η₁, η₂, η₄ and η₅ are shown, respectively in tables 4, 5, 6, 8 and 9.

Since the firing activity of element P_k represents a single bit that helps determine the next state or next memory symbol during a UDM 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 P₀, P₁, P₂, P₃, P₄ and P₅, which collectively represent the computation of η(UXW, YZ), then this leaking of information could be used to reconstruct some or all of the UDM memory contents.

This weakness can be rectified as follows. For each UDM computational step, the active element machine uses six additional quantum random bits b₀, b₁, b₂, b₃, b₄ and b₅. For element P₃, if random bit b₃=1, then the dynamical connections from D₀, D₁, . . . D₁₃ to P₃ are chosen as described above. However, if random bit b₃=0, then the amplitudes of the connections from D₀, D₁, . . . D₁₃ to P₃ and the threshold of P₃ are multiplied by −1. This causes P₃ to fire when η(UXW, YZ)=0 and P₃ doesn't fire when η(UXW, YZ)=1.

This cloaking of P₃'s firing activity can be coordinated with a meta command based on the value of b₃ so that P₃'s firing can be appropriately interpreted to dynamically change the active elements and connections that update the memory contents and state after each UDM computational step. This cloaking procedure can also be used for element P₀ and random bit b₀, P₁ and random bit b₁, P₂ and random bit b₂, P₄ and random bit b₄, and P₅ and random bit b₅.

Besides representing and computing the program t with quantum random firing patterns, there are other important functions computed by active elements executing the UDM. Assume that these connections and the active element firing activity are kept perfectly secret as they represent the state and the memory contents of the UDM memory contents. These functions are described below.

Three active elements (q 0), (q 1) and (q 2) store the current state of the UDM.

There are a collection of elements to represent the machine address k (memory address k of the digital computer) where k is an integer.

A marker active element locates the leftmost machine address (lowest memory address used by the digital computer) and a separate marker active element locates the rightmost memory address (highest memory address used by the digital computer). Any memory symbols outside these markers are assumed to be blank i.e. 0. If the machine head moves beyond the leftmost memory address, then 's connection is removed and updated one memory address to the left (one memory cell lower in the digital computer) and the machine is reading a 0. If the machine head moves beyond the rightmost memory address, then 's connection is removed and updated one memory address 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 UDM (digital computer). For each memory address k inside the marker elements, there are two elements named (S k) and (T k) whose firing pattern determines the alphabet symbol at memory address k (memory cell k). For example, if elements (S 5) and (T 5) are not firing, then memory address 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 memory address −7 (memory cell −7) contains alphabet symbol 1. If element (S 13) is firing and element (T 13) is firing, then memory address 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 machine head moves beyond the initial tape contents (memory contents) of the UDM (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 Deterministic 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).

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

The following program enables a new state to be copied.

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

The sequence of steps by which the UDM (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 machine head (location of the next instruction in memory) is initialized to memory address k=0 and the current machine state is initialized to q₂. 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 a_in and the current state (q 0), (q 1), (q 2) is copied to q_in.

4. r/(q_in, a_in)=(q_out, a_out, m) is computed where q_out represents the new state, a_out represents the new tape symbol and m represents the machine head move.

5. If q_out=h, then the UDM halts. The AEM reaches a static firing pattern that stores the current tape contents indefinitely and keeps the machine head fixed at memory address k where the UDM halted (where the digital computer stopped executing its computer program).

6. Otherwise, the firing pattern of the three elements representing q_out are copied to (q 0), (q 1), (q 2). a_out is copied to the current memory address (memory cell) represented by (S k), (T k).

7. If m=L, then first determine if the machine head has moved to the left of the memory address marked by L. If so, then have L remove its current marker and mark memory address k−1. In either case, go back to step 3 where (S k−1) and (T k−1) are copied to a_in.

8. If m=R, then first determine if the machine head (location of the next instruction in memory) has moved to the right of the memory address marked by R. If so, then have R remove its current marker and mark memory address k+1. In either case, go back to step 3 where (S k+i) and (T k+i) are copied to a_in.

In reference [5], it was shown that quantum randomness is Turing incomputable (digital computer incomputable). Since the firing pattern of the active elements {A₀, A₁, . . . A₁₄} computing η₀; the firing pattern of elements {B₀, B₁, . . . B₁₅} computing η₁; the firing pattern of elements {C₀, C₁, . . . C₁₄} computing η₂; the firing pattern of active elements {D₀, D₁, . . . D₁₃} computing η₃; the firing pattern of active elements {E₀, E₁, . . . E₁₂} computing η₄; and the firing pattern of active elements {F₀, F₁, . . . F₁₃} computing are all generated from quantum randomness, these firing patterns are Turing incomputable. As a consequence, there does not exist a Deterministic machine (digital computer program) that can map these firing patterns back to the sequence of instructions executed by the universal Deterministic 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.

Machine and Affine Map Correspondence

Definition 2.1 Deterministic Machine

A deterministic machine (Q, A, η) satisfies

• • There is a unique machine state h, called the halt state.
  • Q is a finite set of machine states that does not contain the halt state h. The machine states are represented as Q={q₁, q₂, . . . q_K} or as the natural numbers Q={2, . . . , K} and the halt state as 1. Before machine execution begins, there is a starting machine state s and s is an element of Q.
  • L and R are special symbols that instruct the machine to advance to the left adjacent memory address or to the right adjacent memory address of the memory T.
  • A is a finite set of alphabet symbols that are read from and written to memory. The alphabet symbols are denoted as A={a₁, a₂, . . . , a_J} or as the natural numbers A={1, 2, . . . , J}. A does not contain the symbols L, R.
  • η is a function where η: Q×A→(Q∪{h})×A×{L, R}.

The η function serves as the machine instructions (computer program) for the 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 read alphabet symbol a in memory:

• • 1) Machine (Q, A, η) changes to state r.
  • 2) Machine (Q, A, η) rewrites alphabet symbol α as symbol β in memory.
  • 3.) If x=L, then machine (Q, A, η) moves to memory index one to the left in the memory and is subsequently reads the symbol at this memory address.
  • 4.) If x=R, then machine (Q, A, η) moves its memory index one to the right in memory and is subsequently reading the symbol in this memory address.
  • 5) If r=h, machine (Q, A, η) enters the halting state h, and the machine stops (halts).

Definition 2.2 Memory Contents of the Machine

The machine's memory contents is represented as a function T: Z→A where Z denotes the integers. The memory contents T are 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 stored in the kth address of memory is denoted as T_k.

Definition 2.3 Machine Configuration with Memory Address Location

Let (Q, A, η) be a machine with memory contents T. A configuration is an element of the set =(Q∪{h})×Z×{T: T is the memory with range A}. A physical machine has the initial memory contents, which are M-bounded and the memory contents contain only blank symbols, denoted as #, outside the bound M.

If (q, k, T) is a configuration in , then k is called the memory address location. The memory address location is M-bounded if there exists a natural number M>0 such that the address k of memory being read or scanned satisfies |k|≤M. A configuration whose first coordinate equals h is called a halted configuration. The set of non-halting configurations is ={(q, k, T)∈:q≠h}

The purpose of the definition of a configuration is that the first coordinate stores the current state of the machine, the third coordinate stores the contents of the memory, and the second coordinate stores the location (address) of the head reading or scanning the memory. Before presenting some examples of configurations, it is noted that there are different methods to describe the memory contents. One method is

$T\left(k\right)=\left\{\begin{array}{cc}{\alpha }_k& \mathrm{if}l\le k\le n\\ \pounds & \mathrm{otherwise}\end{array}\right\}.$ This is a max. {|l|, |n|}-bounded memory. Another convenient representation is to list the memory contents and underline the symbol to indicate the location of the machine head. ( . . . ##αβ## . . . ).

A diagram can also represent the memory, location of the head reading memory, and the machine configuration (q, k, T). See FIG. 14.

Example 2.4 Deterministic Machine Configuration

Consider configuration (p, 2, . . . ##αβ## . . . ). The first coordinate indicates that the machine is in machine state p. The second coordinate indicates that the machine is currently scanning memory address 2, denoted as T₂ or T(2). The third coordinate indicates that memory address 1 stores symbol α, memory address 2 stores symbol β, and all other memory addresses contain the # symbol.

Example 2.5 Halt Configuration Represented as Natural Numbers

A second example of a configuration is (1, 6, . . . 1111233111 . . . ). This configuration is a halted configuration. The first coordinate indicates that the machine is in halt state 1. The second coordinate indicates that the machine head is scanning memory address 6. The underlined 2 in the third coordinate indicates that the machine 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 Deterministic Machine Computational Step

Consider machine (Q, A, η) with machine configuration (q, k, T) such that T(k)=a, which means that memory address k stores symbol α. After the execution of one computational step, the new configuration is one of the three cases such that for all three cases S(k)=β and S(j)=T(j) whenever j≠k:

• • Case I. (r, k−1, S) if η(q, α)=(r, β, L).
  • Case II. (r, k+1, S) if η(q, α)=(r, β, R).
  • Case III. (h, k, T). In this case, the machine execution stops (halts).

If the machine is currently in machine configuration (q₀, k₀, T₀) and over the next n steps the sequence of machine configurations (points) is (q₀, k₀, T₀), (q₁, k₁, T₁), . . . , (q_n, k_n, T_n) then this execution sequence is sometimes called the next n+1 computational steps.

If Deterministic 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 machine configuration (s, k, T).

The program symbol η, representing the deterministic computer program induces a map η:→ where η(q, k, T)=(r, k−1, S) when η(q, α)=(r, β, L) and η(q, k, T)=(r, k+1, S) when η(q, α)=(r, β, R).

Definition 2.7 Computer Program Size

The program size is the number of elements in the domain of η. The program size 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 Memory Head glb , lub , Window of Execution [,]

Suppose a deterministic machine begins or continues its execution with machine head at memory address k. During the next N computational steps, the greatest lower bound of the machine head is the left most (smallest integer) memory address that the machine head reads during these N computational steps; and the least upper bound of the machine head is the right most (largest integer) memory address that the machine head visits during these N computational steps. The window of execution denoted as [, ] or [, +1, . . . , −1, ] is the sequence of integers representing the memory address that the machine head visited during these N computational steps. The length of the window of execution is −+1 which is also the number of distinct memory addresses visited (read) by the machine head during these N steps. To express the window of execution for the next n computational steps, the lower and upper bounds are expressed as a function of n: [(n), (n)].

Example 2.9 Q={q, r, s, t, u, v, w, x}. A={1, 2}

Halting state=h

η(q, 1) = (r, 1, R).	η(q, 2) = (h, 2, R).	η(r, 1) = (h, 1, R).	η(r, 2) = (s, 2, R).
η(s, 1) = (t, 1, R).	η(s, 2) = (h, 2, R).	η(t, 1) = (h, 1, R).	η(t, 2) = (u, 2, R).
η(u, 1) = (h, 1, R).	η(u, 2) = (v, 1, R).	η(v, 1) = (h, 1, R).	η(v, 2) = (w, 2, R).
η(w, 1) = (h, 1, R).	η(w, 2) = (x, 1, L).	η(x, 1) = (h, 1, R).	η(x, 2) = (q, 2, R).
Left pattern = 12.	Spanning Middle Pattern = 121 2212.	Right pattern = 212.

The machine execution steps are shown in FIG. 15 with machine head initially reading memory address 1. The machine head address is underlined. The machine head moves are {R⁶LR}ⁿ. The point p=[q, 121212222] is an immortal periodic point with period 8 and hyperbolic degree 6.

Remark 2.10

If j≤k, then [(j), (j)]⊆[(k), (k)]

This follows immediately from the definition of the window of execution.

Since the machine addresses may be renumbered without changing the results of the machine execution, for convenience it is often assumed that the machine starts execution at memory address 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 machine addresses 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={a₁, a₂, . . . , a_J} and the machine states are Q={q₁, q₂, . . . q_K}. Define the symbol value function v: A∪Q∪{h}→N where N denotes the natural numbers. v(h)=0. v(a_k)=k. v(q_k)=k+|A|. v(q_K)=|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 Deterministic Machine Program Isomorphism

Two deterministic computing machines M₁(Q₁, A₁, η₁) and M₂(Q₂, A₂, η₂) have a program isomorphism denoted as Ψ: M₁→M₂ if

• • A. There is a function ϕ:Q₁→Q₂ that is a bijection.
  • B. There is a function γ:A_i→A₂ that is a bijection.
  • C. There is a function Ψ: M₁→M₂ such that for each pair (q, a) in Q₁×A₁Ψ(η₁(q,a))=η₂(ϕ(q), γ(a))

Remark 2.13

If alphabet A={a}, then the halting behavior of the deterministic machine is completely determined in ≤|Q|+1 execution steps.

Proof.

Suppose Q={q₁, q₂, . . . q_K}. 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: η(q_S(1), a)→η(q_S(2), a)→η(q_S(3), a) . . . →η(q_S(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 η(q_s(i), a)→ . . . →η(q_s(j), a) indefinitely. If the program does not halt in |Q|+1 execution steps, then the computer 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

Register Machine Configuration to x-y plane P correspondence. See FIG. 14. For a fixed machine (Q, A, η), each configuration (q, k, T) represents a unique point (x, y) in P. The coordinate functions x:→P and y:→P, where is the set of configurations, are x(q, k, T)=T_k T_k+1·T_k+2 T_k+3 T_k+4 . . . where this decimal sequence in base B represents the rational number

$\mathrm{Bv}\left(T_k\right)+v\left(T_{k+1}\right)+\underset{j=1}{\sum ^{\infty }}v\left(T_{k+j+1}\right)B^{-j}$ y(q, k, T)=q T_k−1·T_k−2 T_k−3 T_k−4 . . . where this decimal sequence in base B represents a rational number as

$\mathrm{Bv}\left(q\right)+v\left(T_{k-1}\right)+\underset{j=1}{\sum ^{\infty }}v\left(T_{k-j-1}\right)B^{-j}$

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

Definition 2.15 Equivalent Configurations

With respect to Deterministic machine (Q, A, η), the two configurations (q, k, T) and (q, j, V) are equivalent [i.e. (q, k, T)˜(q, j, V)] if T(m)=V(m+j−k) for every integer m. Observe that ˜ is an equivalence relation on . Let ′ denote the set of equivalence classes [(q, k, T)] on . Also observe that φ maps every configuration in equivalence class [(q, k, T)] to the same ordered pair of real numbers in P. Recall that (D, X) is a metric space if the following three conditions hold.

• • 1. D(a, b)≥0 for all a, b in X where equality holds if and only if a=b.
  • 2. D(a, b)=D(b, a) for all a, b. (Symmetric)
  • 3. D(a, b)=D(a, c)+D(c, b) for all a, b, c in X. (Triangle inequality.)

(ρ, ′) is a metric space where ρ is induced via φ by the Euclidean metric in P. Consider points p₁, p₂ in P with p₁=(x₁, y₁) and p₂=(x₂, y₂) where (d, P) is a metric space with Euclidean metric d(p₁, p₂)=√{square root over ((x₁−x₂)²+(y₁−y₂)²)}

Let u=[(q, k, S)], w=[(r, l, T)] be elements of ′. Define ρ:′×′→R as ρ(u, w)=d(φ(u), φ(w))=√{square root over ([x(q,k,S)−x(r,l,T)]²+[y(q,k,S)−y(r,l,T)]²)}

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 machine head locations and with all corresponding symbols on their respective tapes being equal) into the same point in ′.

The unit square U_{(└x┘, └y┘)} has a lower left corner with coordinates (└x┘, └y┘) where └x┘=Bv(T_k)+v(T_k+1) and └y┘=Bv(q)+v(T_k−1). See FIG. 16.

Definition 2.16 Left Affine Function

This is for case I. where η(q, T_k)=(r, β, L). See FIG. 17.

• • x a T_k−1β·T_k+1 T_k+2 T_k+3 . . .
  • B⁻¹ x=T_k·T_k+1 T_k+2 T_k+3 T_k+4

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

• • y a r T_k−2 T_k−3 T_k−4 T_k−5 . . .
  • By=q T_k−1 T_k−2·T_k−3 T_k−4 T_k−5 . . . .

Thus, n=rT_k−2−qT_k−1 T_k−2 where the subtraction of integers is in base B.

Define the left affine function F_{(└x┘, └y┘)}:U_{(└x┘, └y┘)}→P where

$F_{\left({\lfloor }_x\rfloor ,{\lfloor }_y\rfloor \right)}\left(\begin{array}{c}x\\ y\end{array}\right)=\left(\begin{array}{cc}\frac{1}{B}& 0\\ 0& B\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}m\\ n\end{array}\right),$ m=Bv(T_k−1)+v(β)−v(T_k) and n=Bv(r)−B²v(q)−Bv(T_k−1).

Lemma 2.17 Left Affine Function⇔Register Machine Computational Step

Let (q, k, T) be a Deterministic machine configuration. Suppose η(q, T_k)=(r, b, L) for some state r in Q∪{h} and some alphabet symbol b in A and where T_k=a. Consider the next Deterministic Machine computational step. The new configuration is (r, k−1, T_k) where T^b(j)=T(j) for every j≠k and T^b(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, T^b), y(r, k−1, T^b)].

Proof.

• • x(r, k−1, T^b)=T_k−1b·T_k+1 T_k+2 . . . .

The x coordinate of

$F_{\left({\lfloor }_x\rfloor ,{\lfloor }_y\rfloor \right)}\left[x\left(q,k,T\right),y\left(q,k,T\right)\right]=B^{-1}x\left(q,k,T\right)+Bv\left(T_{k-1}\right)+v\left(b\right)-v\left(a\right)=B^{-1}(a{T}_{k+1}·T_{k+2}{T}_{k+3}\dots )+\mathrm{Bv}\left(T_{k-1}\right)+v\left(b\right)-v\left(a\right)=a·T_{k+1}{T}_{k+2}{T}_{k+3}\dots +Bv\left(T_{k-1}\right)+v\left(b\right)-v\left(a\right)=T_{k-1}b·T_{k+1}{T}_{k+2}{T}_{k+3}\dots$

• • y(r, k−1, T^b)=rT_k−2·T_k−3 T_k−4 . . . .

The y coordinate of

$F_{\left({\lfloor }_x\rfloor ,{\lfloor }_y\rfloor \right)}\left[x\left(q,k,T\right),y\left(q,k,T\right)\right]=\mathrm{By}\left(q,k,T\right)+Bv\left(r\right)-B^{2}v\left(q\right)-Bv\left(T_{k-1}\right).=B(q{T}_{k-1}·T_{k-2}{T}_{k-3}\dots )+\mathrm{Bv}\left(r\right)-B^{2}v\left(q\right)-Bv\left(T_{k-1}\right).=q{T}_{k-1}{T}_{k-2}·T_{k-3}\dots +\mathrm{Bv}\left(r\right)-B^{2}v\left(q\right)-Bv\left(T_{k-1}\right).={\mathrm{rT}}_{k-2}·T_{k-3}{T}_{k-4}\dots =y\left(r,k-1,T^b\right).$

Remark 2.18 Minimum Vertical Translation for Left Affine Function

As in 2.16, n is the vertical translation. |Bv(r)−Bv(T_k−1)|=B|v(r)−v(T_k−1)|≤B(B−1). Since q is a state, v(q)≥(|A|+1). This implies |−B²v(q)|≥(|A|+1)B² This implies that |n|≥(|A|+1)B²−B(B−1)≥|A| B²+B.

Thus, |n|≥|A| B²+B.

Definition 2.19 Right Affine Function

This is for case II. where η(q, T_k)=(r, β, R). See FIG. 18.

• • x a T_k+1 T_k+2·T_k+3 T_k+4 . . .
  • B x=T_k T_k+1 T_k+2·T_k+3 T_k+4 . . . .

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

• • y a rβ·T_k−1 T_k−2 T_k−3 . . .
  • By=q T_k−1 T_k−2·T_k−3 T_k−4 T_k−5 . . . .

Thus, n=rβ−q where the subtraction of integers is in base B.

Define the right affine function G_{(└x┘, └y┘)}:U_{(└x┘, └y┘)}→P such that

$G_{\left({\lfloor }_x\rfloor ,{\lfloor }_y\rfloor \right)}\left(\begin{array}{c}x\\ y\end{array}\right)=\left(\begin{array}{cc}B& 0\\ 0& \frac{1}{B}\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}m\\ n\end{array}\right)$ where m=−B²v(T_k) and n=Bv(r)+v(β)−v(q).

Lemma 2.20 Right Affine Function⇔Deterministic Machine Computational Step

Let (q, k, T) be a Deterministic machine configuration. Suppose η(q, T_k)=(r, b, R) for some state r in Q∪{h} and some alphabet symbol b in A and where T_k=a. Consider the next Deterministic Machine computational step. The new configuration is (r, k+1, T^b) where T^b(j)=T(j) for every j≠k and T^b(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, T^b), y(r, k+1, T^b)].

Proof.

From η(q, T_k)=(r, b, R), it follows that x(r, k+1, T^b)=T_k+1 T_k+2·T_k+3 T_k+4 . . . .

The x coordinate of

$G_{\left({\lfloor }_x\rfloor ,{\lfloor }_y\rfloor \right)}\left[x\left(q,k,T\right),y\left(q,k,T\right)\right]=\mathrm{Bx}\left(q,k,T\right)-B^{2}v\left(a\right)=B(a{T}_{k+1}·T_{k+2}{T}_{k+3}{T}_{k+4}\dots )-B^{2}v\left(a\right)=a{T}_{k+1}{T}_{k+2}·T_{k+3}{T}_{k+4}\dots -B^{2}v\left(a\right)=T_{k+1}{T}_{k+2}·T_{k+3}{T}_{k+4}=x\left(r,k+1,T^b\right)$

From η(q, T_k)=(r, b, R), it follows that y(r, k+1, T^b)=rb·T_k−1 T_k−2 T_k−3 . . . .

They coordinate of

$G_{\left({\lfloor }_x\rfloor ,{\lfloor }_y\rfloor \right)}\left[x\left(q,k,T\right),y\left(q,k,T\right)\right]=B^{-1}y\left(q,k,T\right)+Bv\left(r\right)+v\left(b\right)-v\left(q\right)=B^{-1}(q{T}_{k-1}·T_{k-2}{T}_{k-3}\dots )+\mathrm{Bv}\left(r\right)+v\left(b\right)-v\left(q\right)=q·T_{k-1}{T}_{k-2}{T}_{k-3}\dots +Bv\left(r\right)+v\left(b\right)-v\left(q\right)=\mathrm{rb}·T_{k-1}{T}_{k-2}{T}_{k-3}\dots =y\left(r,k+1,T^b\right).$

Remark 2.21 Minimum Vertical Translation for Right Affine Function

First,

$v\left(\beta \right)-v\left(q\right)\le B-1.$ $n=\mathrm{Bv}\left(r\right)+v\left(\beta \right)-v\left(q\right)\ge \mathrm{Bv}\left(r\right)-\left(B-1\right)\ge \left(A+1\right)B-\left(B-1\right)\mathrm{because}v\left(r\right)\ge A+1=AB+1.$ $\mathrm{Thus},n\ge AB+1.$

Definition 2.22 Function Index Sequence and Function Sequence

Let {ƒ₁, ƒ₂, . . . , ƒ_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 {ƒ₁, ƒ₂, . . . , ƒ_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, [ƒ₀, ƒ₁, ƒ₀, ƒ₁, . . . ] is written when formally this function index sequence is S:N→{0, 1} where S(n)=n mod 2.

Example 2.23

$\begin{array}{cc}f\left(\begin{array}{c}x\\ y\end{array}\right)=\left(\begin{array}{cc}\frac{1}{4}& 0\\ 0& 4\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}4\\ 0\end{array}\right)& \end{array}$ on domain U_(0,0) and

$\begin{array}{cc}g\left(\begin{array}{c}x\\ y\end{array}\right)=\left(\begin{array}{cc}\frac{1}{4}& 0\\ 0& 4\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}-1\\ 0\end{array}\right)& \end{array}$ on U_(4,0)

$\begin{array}{cc}g\circ f\left(\begin{array}{c}x\\ y\end{array}\right)=\left(\begin{array}{cc}\frac{1}{16}& 0\\ 0& 16\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}0\\ 0\end{array}\right)\mathrm{and}f\left(\begin{array}{c}0\\ 0\end{array}\right)=\left(\begin{array}{c}4\\ 0\end{array}\right)f\left(\begin{array}{c}1\\ 0\end{array}\right)=\left(\begin{array}{c}4.25\\ 0\end{array}\right)f\left(\begin{array}{c}0\\ 1\end{array}\right)=\left(\begin{array}{c}4\\ 1\end{array}\right)& \end{array}$ (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:U_k→P is a function for each k such that whenever j≠k, then U_j∩U_k=Ø. For any point p in the plane P an orbit may be generated as follows. The 0^th iterate of the orbit is p. Given the kth iterate of the orbit is point q, if point q does not lie in any U_k, then the orbit halts. Otherwise, q lies in at least one U_j. Inductively, the k+1 iterate of q is defined as ƒ_j(q). If p has an orbit that never halts, this orbit is called an immortal orbit and p is called an immortal point. If p has an orbit that halts, this orbit is called a halting orbit and p is called a halting point.

Theorem 2.25 Register Machine Execution⇔Affine Map Orbit Halting/Immortal Orbit Correspondence Theorem

Consider Register machine (Q, A, η) with initial machine configuration (s, 0, T). W.L.O.G., it is assumed that the machine begins executing with the machine head at zero. Let ƒ₁, ƒ₂, . . . , ƒ_I denote the I affine functions with corresponding unit square domains W₁, W₂, W₃, . . . , W_I determined from 2.14, 2.15, 2.16 and 2.19. Let p=(x(s, 0, T), y(s, 0, T)). Then from 2.14,

$x\left(s,0,T\right)=Bv\left(T_0\right)+v\left(T_1\right)+\sum _{j=1}^{\infty }v\left(T_{j+1}\right)B^{-j}.$ Also,

$y\left(s,0,T\right)=Bv\left(s\right)+v\left(T_{-1}\right)+\sum _{j=1}^{\infty }v\left(T_{-j-1}\right)B^{-j}.$ There is a 1 to 1 correspondence between the mth point of the orbit

$\begin{array}{cc}\left[p,f_{S\left(1\right)}\left(p\right),f_{S\left(2\right)}{f}_{S\left(1\right)}\left(p\right),\dots ,f_{S\left(m\right)}{f}_{S\left(m-1\right)}\dots f_{S\left(2\right)}{f}_{S\left(1\right)}\left(p\right),\dots \right]\subseteq \underset{k=1}{\overset{I}{U}}{W}_k& \end{array}$ and the mth computational step of the deterministic machine (Q, A, η) with initial configuration (s, 0, T). In particular, the Deterministic Machine halts on initial configuration (s, 0, T) if and only if p is a halting point with respect to affine functions ƒ_k:W_k→P where 1≤k≤I Dually, the Deterministic Machine is immortal on initial configuration (s, 0, T) if and only if p is an immortal point with respect to affine functions ƒ_k:W_k→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

$p_0=\left[x\left(s,0,T\right),y\left(s,0,T\right)\right]\mathrm{exits}\underset{k=1}{\overset{I}{U}}{W}_k$ on the Nth iteration of the orbit. Thus, p₀ is a halting point.

Corollary 2.26 Immortal Periodic Points, Induced by Configurations, Correspond to Equivalent Configurations that are Immortal Periodic.

$\underset{k=1}{\overset{I}{U}}{W}_k$

Proof.

Suppose p [x(q, k, T), y(q, k, T)] with respect to (Q, A, η) and p lies in k=1 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, j_k, V_k) 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

$\underset{k=1}{\overset{I}{U}}{W}_k$ such that ƒ_S(N) ƒ_S(N−1) . . . ƒ_S(1)(p)=p. Starting with configuration (q, k, T), after N execution steps of (Q, A, η), the resulting configuration (q, j, V) satisfies x(q, k, T)=x(q, j, V) and y(q, k, T)=y(q, j, V) because of ƒ_S(N) ƒ_S(N−1) . . . ƒ_S(1)(p)=p and Theorem 2.25. This implies that (q, k, T) is translation equivalent to (q, j, V).

By induction this argument may be repeated indefinitely. Thus, (q, k, T) is an immortal configuration such that for every N computational steps of (Q, A, η), the kth resulting configuration (q, j_k, V_k) 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 deterministic 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(T_k)+v(T_k+1) and └y┘=Bv(q)+v(T_k−1). A left or right affine function (left or right move) is determined by the state q and the current memory address T_k. 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 Deterministic 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 T_k. 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 ƒ₁, ƒ₂, . . . , ƒ_I denote the I affine functions with corresponding unit square domains W₁, W₂, . . . , W_I. 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

$z=\left(\frac{p_1}{q_1},\frac{p_2}{q_2}\right)$ in the orbit, where p₁, p₂, q₁, and q₂ are integers in reduced form, then |p₁|<M, |p₂|<M, |q₁|<M, and |q₂|<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 p₁, p₂, q₁ and q₂ 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 Deterministic machine execution whose machine 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 Deterministic 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 g₁, g₂, . . . , g_k, . . . such that for each natural number n the composition of functions g_S(n)g_S(n−1) . . . g_S(1) iterated up to the s(n)th orbit point is of the form

$\left(\begin{array}{cc}{B}^n& 0\\ 0& \frac{1}{B^n}\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}{m}_{s\left(n\right)}\\ t_{s\left(n\right)}\end{array}\right)$

where m_s(n), t_s(n) are rational numbers.

Corollary 2.34

If the Deterministic 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 g₁, g₂, . . . , g_k, . . . such that for each natural number n the composition of functions g_S(n) g_S(n−1) . . . g_S(1) iterated up to the s(n)th orbit point is of the form:

$\left(\begin{array}{cc}\frac{1}{B^n}& 0\\ 0& B^n\end{array}\right)\left(\begin{array}{c}x\\ y\end{array}\right)+\left(\begin{array}{c}{m}_{s\left(n\right)}\\ t_{s\left(n\right)}\end{array}\right)$ where m_s(n), t_s(n) are rational numbers.

Theorem 2.35 M-Bounded Execution Implies a Halting or Periodic Orbit

Suppose that the Deterministic Machine (Q, A, η) begins or continues execution with a configuration such that its machine head location is M-bounded during the next (2M+1)|Q∥A|^2M+1+1 execution steps. Then the Deterministic 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 machine head location. There are a maximum of (2M+1) machine head locations. For each of the remaining 2M memory address, each square can have at most |A| different symbols, which means a total of |A|^2M possibilities for these memory address. Thus, in the first (2M+1)|Q∥A|^2M+1+1 points of the corresponding orbit in P, there are at most distinct (2M+1)|Q∥A|^2M+1 points so at least one point in the orbit must occur more than once.

Prime Edge Machine Computation

Any digital computer program (e.g., a program written in C, Python, C++, JAVA, Haskell) can be compiled to a finite number of prime directed edges. Prime directed edges acts as machine instructions. Overlap matching and intersection patterns determine how the prime directed edges store the result of one step of the computation in the memory.

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=v₀ v₁ . . . v_n, pattern W=w₀ w₁ . . . w_n with heads s, t satisfying 0≤s, t≤n and pattern P=p₀ p₁ . . . p_m with head u satisfying 0≤u≤m. Suppose (P, u) overlap matches (V, s). Then define the edge pattern substitution operator ⊕ as E=(P, u)⊕[(V, s)⇒(W, t)] according to the four different cases A., B., C. and D.

Case A.) u>s and m−u>n−s. See FIG. 19.

$E\left(k\right)=\left\{\begin{array}{ccc}W\left(k+s-u\right)& \mathrm{wh}\mathrm{en}& u\le k+s\le u+n\\ P\left(k\right)\mathrm{when}& 0\le k<u-s& \mathrm{OR}& u+n-s<k\le m\end{array}\right\}$

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

Case B.) u>s and m−u≤n−s. See FIG. 20.

$E\left(k\right)=\left\{\begin{array}{ccc}W\left(k+s-u\right)& \mathrm{wh}\mathrm{en}& u-s\le k\le n+s-u\\ P\left(k\right)& \mathrm{wh}\mathrm{en}& 0\le k<u-s\end{array}\right\}$

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

Case C.) u≤s and m−u≤n−s. See FIG. 21.

E(k)=W(k) when 0≤k≤n and the head of E is t. Also, |E|=|W|=n+1.

Case D.) u≤s and m−u>n−s. See FIG. 22.

$E\left(k\right)=\left\{\begin{array}{ccc}P\left(k+u-s\right)& \mathrm{wh}\mathrm{en}& n<k\le m+s-u\\ W\left(k\right)& \mathrm{wh}\mathrm{en}& 0\le k\le n\end{array}\right\}$

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

Overlap and intersection matching and edge pattern substitution are useful for computing algorithms that execute all possible finite machine configurations for a digital computer program.

Example 3.3 Overlap Matching and Edge Substitution

Set pattern P=0101 110. Set pattern V=11 0101. Set pattern W=01 0010. Then (P, 0) overlap matches (V, 2). Edge pattern substitution is well-defined so E=(P, 0)⊕[(V, 2)⇒(W, 4)]=01 0010 110. The head or index of pattern E=4. Also, (P, 4) overlap matches (V, 0). F=(P, 4)⊕[(V, 0)⇒(W, 4)]=0101 010010. The index of pattern F=u+t−s=4+4−0=8.

Remark 3.5 Any Prime State Cycle has Length≤|Q|

This follows from the Dirichlet principle and the definition of a prime machine 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 machine instruction and |A| choices for the second input machine instruction since the machine states must match. Thus, there are |Q∥A|² 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 (q₁, a₁)→(q₂, a₂)→(q₁, b₁).

Then there are |Q∥A| choices for (q₁, a₁) and once (q₁, a₁) is chosen there is only one choice for q₂ because it is completely determined by η(q₁, a₁)=(q₂, b₁) where η is the program in (Q, A, η). Similarly, there is only one choice for b₁. There are |A| choices for a₂. Thus, there are |Q∥A|² distinct choices.

For an arbitrary prime state cycle (q₁, a₁)→(q₂, a₂)→ . . . →(q_n, a_n)→(q₁, a_n+1) with window of execution of length k then there are |Q∥A| choices for (q₁, a₁) and |A| choices for a₂ since the current window of execution length after the first step increases by 1. There is only one choice for q₂ because it is determined by η(q₁, a₁). Similarly, for the jth computational step, if the current window of execution length increases by 1, then there are |A| choices for (q_j+1, a_j+1). Similarly, for the jth computational step, if the current window of execution stays unchanged, then there is only one choice for a_j+1 that was determined by one of the previous j computational steps. Thus, there are at most |Q∥A|^k distinct prime state cycles whose window of execution length equals k. Definitions 2.8 and remark 2.10 imply that a prime k-state cycle has a window of execution length less than or equal to k. Thus, from the previous and 3.5, there are at most

$❘Q❘\sum _{k=1}^{❘Q❘}{❘A❘}^k$ distinct prime state cycles in (Q, A, η).

Remark 3.7 any State Cycle Contains a Prime State Cycle

Proof.

Relabeling if necessary let S(q₁, q₁)=(q₁, a₁)→ . . . →(q_n, a_n)→(q₁, a_n+1) be a state cycle. If q₁ is the only state visited twice, then the proof is completed. Otherwise, define μ=min{|S(q_k, q_k)|: S(q_k, q_k) is a subcycle of S(q₁, q₁)}. Then exists because S(q₁, q₁) is a subcycle of S(q₁, q₁). Claim: Any state cycle S(q_j, q_j) with |S(q_j, q_j)|=μ must be a prime state cycle. Suppose not. Then there is a state r≠q_j that is visited twice in the state cycle S(q_j, q_j). But then S(q_r, q_r) is a cycle with length less than which contradicts μ's definition.

Definition 3.9 Execution Node for (Q, A, η)

An execution node (or node) is a triplet H=[q, w₀ w₁ . . . w_n, t] for some state q in Q where w₀ w₁ . . . w_n is a pattern of n+1 alphabet symbols each in A such that t is a non-negative integer satisfying 0≤t≤n. Intuitively, w₀ w₁ . . . w_n is the pattern of alphabet symbols on n+1 consecutive memory addresses in the computer memory and t represents the location (address) of memory, where the next computational step (i.e. machine instruction) of the prime directed edge computation will be stored in memory.

Prime Directed Sequences

Definition 4.1 Prime Directed Edge from Head and Tail Execution Nodes a Prime Head Execution Node Δ=[q, v₀ v₁ . . . v_n, s] and Prime Tail Execution Node

Γ=[r, w₀ w₁ . . . w_n, t] are called a prime directed edge if and only if all of the following hold:

• • When register machine (Q, A, η) starts execution, it is in state q; the machine head is pointing to memory address s. For each j satisfying 0≤j≤n memory address j contains symbol v_j. In other words, the initial pattern stored in memory is v₀ v₁ . . . v_s . . . v_n.
  • During the next N computational steps, machine state r is visited twice and all other states in Q are visited at most once. In other words, the corresponding sequence of input instructions during the N computational steps executed contains only one prime state cycle.
  • After N computational steps, where 1≤N≤|Q|, the register machine is in machine state r. The machine head is located at memory address t. For each j satisfying 0≤j≤n memory address j contains symbol w_j. The tape pattern after the N computational steps is w₀ w₁ . . . w_t . . . w_n.
  • The window of execution for these N computational steps is [0, n].

A prime directed edge is denoted as Δ⇒Γ or [q, v₀ v₁ . . . v_n, s]⇒[r, w₀ w₁ . . . w_n, t]. The number of computational steps Nis denoted as |Δ⇒Γ|.

Definition 4.2 Prime Input Instruction Sequence

3.4 introduced input instructions. If (q₁, a₁)→ . . . →(q_n, a_n) is an execution sequence of input instructions for (Q, A, η), then (q₁, a₁)→ . . . →(q_n, a_n) is a prime input command sequence if q_n 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.

Definition 4.23 Prime Directed Edge Complexity

• • Let P={Δ₁⇒Γ₁, . . . , Δ_k⇒Γ_k, . . . , Δ_N⇒Γ_N} denote the finite set of prime directed edges for machine (Q, A, η). Define the prime directed edge complexity of deterministic 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 deterministic machine.

Definition 4.24 Overlap Matching of a Node to a Prime Head Node

Execution node Π overlap matches prime head node Δ if and only if the following hold.

• • Π=[r, w₀ w₁ . . . w_n, t] is an execution node satisfying 0≤t≤n
  • Δ=[q, v₀ v₁ . . . v_n, s] is a prime head node satisfying 0≤s≤m
  • Machine State q=Machine State r.
  • W denotes pattern w₀ w₁ . . . w_n and V denotes pattern v₀ v₁ . . . v_m
  • Pattern (W, t) overlap matches (V, s) as defined in definition 3.1.

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 memory I, pointing to memory address m in the machine is 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 machine head exits finite tape I. This means the machine would execute the same machine instructions with respect to Δ_j and Δ_k up to the ith step, so on the ith step, Δ_j and Δ_k must execute the same machine instruction. Since it exits memory I at the ith computational step, this would imply that either pattern P stored in memory or pattern V stored in memory, are exited at the ith computational 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.

The Edge Node Substitution Operator is a method of machine computation.

Definition 4.26 Edge Node Substitution Operator Π⊕(Δ⇒Γ)

Let Δ⇒Γ be a prime directed edge with prime head node Δ=[q, v₀ v₁ . . . v_n, s] and tail node Γ=[r, w₀ w₁ . . . w_n, t]. If execution node Π=[q, p₀ p₁ . . . p_m, 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=v₀ v₁ . . . v_n and W=w₀ w₁ . . . w_n and P=p₀ p₁ . . . p_m.

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 computational element being a prime directed edge and the second computational element is an execution node. Each computational element is expressed as (Δ_kΓ_k, Π_k).

The first computational element of a prime directed edge sequence is (Δ₁⇒Γ₁, Π₁) where Π₁=Γ₁, and Δ₁⇒Γ₁ is some prime directed edge in P. In some embodiments, (Δ₁⇒Γ₁, Π₁) is executed with one or more register machine instructions. For simplicity in this definition, the memory indices (addresses) in P are relabeled if necessary so the first element has memory indices (addresses) equal to 1. If Π₁ overlap matches some non-halting prime head node Δ₂, the second element of the prime directed edge sequence is (Δ₂⇒Γ₂, Π₂) where Π₂=Π₁⊕(Δ₂⇒Γ₂). This machine computation is called a link match step.

Otherwise, Π₁ overlap matches a halting node, then the prime directed edge sequence terminates. This is expressed as [(Δ₁⇒Γ₁, Γ₁), 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 [(Δ₁⇒Γ₁, Π₁), (Δ₂⇒Γ₂, Π₂), . . . , (Δ_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([p₁, p₂, . . . , p_k], k)

To avoid subscripts of a subscript, p_k and the subscript _p(j) represent the same number. As defined in 4.27, P={Δ₁⇒Γ₁, . . . , Δ_k⇒Γ_k, . . . , Δ_N⇒Γ_N} denotes the set of all prime directed edges. E([p₁], 1) denotes the edge sequence [(Δ_p(1)=⇒Γ_p(1), Π_p(1))] of length 1 where Π_p(1)=Γ_p(1) and 1≤p₁≤|P|. Next E([p₁, p₂], 2) denotes the edge sequence [(Δ_p(1)⇒Γ_p(1), Π_p(1)), (Δ_p(2)⇒Γ_p(2), Π_p(2))] of length 2 where Π_p(2)=Π_p(1)⊕(Δ_p(2)⇒Γ_p(2)) and 1≤p₁, p₂≤|P|.

In general, E([p₁, p₂, . . . , p_k], 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 instructions. The expression an edge sequence contains a consecutive repeating state cycle is used if the corresponding sequence of prime input instructions 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([p₁, p₂, . . . , p_r], r) contains a consecutive repeating state cycle, then the corresponding immortal periodic point has

$\mathrm{period}\le \frac{1}{2}\sum _{k=1}^r❘{\Delta }_{p\left(k\right)}\Rightarrow {\Gamma }_{p\left(k\right)}❘.$

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 instructions 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
instruction sequence (q0, a0) —>
(q1, a1) —> . . . —> (qN, aN) has length N.
Set n = N/2 if N is even; otherwise, set n = (N + 1)/2 if N is odd
for each k in {1, 2, . . ., n}
{
for each j in {0, 1, . . ., N − 2k − 1}
{
if input instruction sequence (qj, aj) —> (qj +1, aj +1)
—>. . . —> (qj +k, aj +k) equals
input instruction sequence (qj +k +1, aj +k +1) —>
(qj +k +2, aj +k +2) —>. . . —> (qj +2k +1, aj +2k +1)
then
{
return consecutive repeating state cycle
(qj, aj) —> (qj +1, aj +1) —>. . . —>
(qj +k, aj +k) —>. . . —> (qj +2k +1, aj +2k +1)
}
}
}
If exited outer for loop without finding a consecutive
repeating state cycle
Return NO consecutive repeating state cycles were found.

Example 4.33 A newLISP Computational Machine that Finds a Consecutive Repeating Sequence

(define (find_pattern_repeats p_length seq)
(let
(
(k 0)
(max_k (− (length seq) (+ p_length p_length)) )
(pattern nil)
(repeat_pair nil)
(no_repeats true)
)
(while (and ( <= k max_k) no_repeats)
(set ‘pattern (slice seq k p_length))
(if (= pattern (slice seq (+ k p_length) p_length))
(begin
(set ‘repeat_pair (list pattern k))
(set ‘no_repeats false)
)
)
(set ‘k (+ k 1))
)
repeat_pair
))
(define (find_repeats seq)
(let
(
(p_length 1)
(max_p_length (/ (length seq) 2) )
(repeat_pair nil)
)
(while (and (<= p_length max_p_length) (not repeat_pair) )
(set ‘repeat_pair (find_pattern_repeats p_length seq))
(set ‘p_length (+ p_length 1))
)
repeat_pair
))
(set ‘s1’ (3 5 7 2 3 5 7 11 5 7) )
;; s1 does not have a consecutive repeating sequence.
(set ‘s2’ (3 5 7 2 3 5 7 11 5 7 11 2 4 6 8) )
;; 5 7 11 5 7 11 is a consecutive repeating sequence starting
at element in list s2
(set ‘s3’ (1 2 0 2 1 0 2 0 1 2 0 2 1 0 1 2 1 0 2 1 2 0 2 1 0 1
2 0 2 1 2 0 1 2 1 0 1 2 0 1 0 1))
;; 0 1 0 1 is a consecutive repeating sequence starting
at element 38 in list s3
> (find_repeats s1)
nil
> (find_repeats s2)
( (5 7 11) 5)
> (find_repeats s3)
( (0 1) 38)

Method 4.34 Prime Directed Edge Search Method

With Machine (Q, A, η) as input, the search computational
method executes as follows.
Set P = Ø.
For each non-halting state q in Q
For each memory pattern a−|Q|...a−2 a−1 a0a1a2 . . .
a|Q| selected from A2|Q|+1
Memory Indices −|Q| −2 −1 0 1 2 |Q|
Memory Contents a−|Q|...a−2 a−1 a0a1a2 . . . a|Q|
{
Initial Machine State q
With memory index pointing to address a0, start executing
machine (Q, A, η) until one
state has been visited twice or (Q, A, η) reaches a halting state.
The Dirichlet principle implies this will take at most |Q|
computational steps. If it does not halt, let r be the
state that is first visited twice. As defined in 4.1, over
this window of execution, a prime directed edge Δ => Γ is
constructed where Δ = [q,v0 v1 . . . vn, s], Γ = [r, w0 w1 . . .
wn, t]and 0 ≤ s, t ≤ n ≤ |Q|.
Set P = P ∪ {Δ = Γ}
}

Remark 4.35 Prime Directed Edge Search Method Finds all Prime Directed Edges

Method 4.34 Finds all prime directed edges of (Q, A, η) and all halting nodes.

Proof.

Let Δ⇒Γ be a prime directed edge of (Q, A, η). Then Δ⇒Γ has a head node A=[r, v₀ v₁ . . . v_n, s], for some state r in Q, for some tape pattern v₀ v₁ . . . v_n that lies in Δⁿ⁺¹ 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₋₂ a₋₁ a₀ a₁ a₂ . . . a_|Q| is selected from A^2|Q|+1 such that

	α0 = νs	α1 = νs+1	. . .	αk = νs+k	. . .	αn−s = νn
	α−1 = νs−1	α−2 = νs−2	. . .	α−k = νs−k	. . .	α−s = ν0

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

Method 4.36 Immortal Periodic Point Search Method

With Register Machine program (Q, A, η) as input, this
computational method executes as
follows. Use method 4.34 to find all prime directed edges, P.
set k = 1.
set Φ(1) = {E( [1], 1), E( [2], 1), . . ., E([ |P| ], 1) }
while (Φ (k) ≠ Ø)
{
set Φ(k + 1) = Ø.
for each E([p1, p2, . . ., pk], k) in Φ(k)
{
for each prime directed edge Δj => Γj in P
{
if Δj => Γj  link matches with Πp(k) then
{
set pk +1 = j
set Φ(k + 1) = Φ(k + 1) ∪ E([p1, p2, . . ., pk, pk +1], k + 1)
if E([p1, p2, . . ., pk, pk +1], k + 1) contains a
consecutive repeating state cycle
then return the consecutive repeating state cycle
}
}
}
k is incremented.
}
if (while loop exited because Φ(m) = Ø for some m) then return Ø

Remark 4.37 |Φ(k)| is finite and |Φ(k)|≤|P|^k

Proof.

|Φ(1)|=|P|. Analyzing the nested loops, in method 4.36

• • for each E([p₁, p₂, . . . , p_k], k) in Φ(k)
    • for each Δ_j⇒Γ_j in P { . . . }

For each edge sequence E([p₁, p₂, . . . , p_k], k) chosen from Φ(k), at most |P| new edge sequences are put in Φ(k+1). Thus |Φ(k+1)|≤|P∥Φ(k)|, so |Φ(k)|≤|P|^k.

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.

REFERENCES

• [1] G. Agnew. Random Source for Cryptographic Systems. Advances in Cryptology—EUROCRYPT 1987 Proceedings. Springer Verlag, 77-81 (1988)
• [2] John Bell. On the Einstein Podolsky Rosen Paradox. Physics. 1, 1964, pp. 195-200.
• [3] P. Benioff. The computer as a physical system: A microscopic quantum mechanical Hamiltonian model of computers as represented by Turing machines. Journal of Statistical
• [4] P. Benioff. Quantum mechanical Hamiltonian models of Turing machines that dissipate no energy. Physics Review Letter. 48, 1581-1585 (1980)
• [5] Simon Kochen and E. P Specker. The Problem of Hidden Variables in Quantum Mechanics. Journal of Mathematics and Mechanics. Vol. 17, No. 1, 59-87 (1967)
• [6] A. A. Abbott, C. S. Calude, J. Conder, and K. Svozil. Strong Kochen-Specker theorem and incomputability quantum randomness. Phys. Rev. A 86, 062109, 1-11 (2012)
• [7] Martin Davis. Computability and Unsolvability. Dover Publications, New York, (1982)
• [8] David Deutsch. Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer. Proc. London Math. Soc. Series A. 400, No. 1818, 97-117 (1985)
• [9] Richard Feynman. Simulating physics with computers. International Journal of Theoretical Physics. 21, 467-488 (1982)
• [10] Richard Feynman. Quantum mechanical computers. Foundations of Physics. 16, 507-531 (1986)
• [11] Michael Stephen Fiske. Active Element Machine Computation. U.S. Pat. No. 8,010,467. (2007)
• [12] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W.H. Freeman, (1979)
• [13] L. K. Grover. Quantum mechanics helps in searching for a needle in a haystack. Physics Review Letters. 79, 325-328. (1997)
• [14] James M. Henle and Eugene M. Kleinberg. Infinitesimal Calculus. Mineola, NY. Dover Publications. (2003)
• [15] John Hertz, Anders Krogh and Richard G. Palmer. Introduction To The Theory of Neural Computation. Addison-Wesley Publishing Company. Redwood City, California, (1991)
• [16] John J. Hopfield. Neural networks and physical systems with emergent collective computational abilities. Proceedings of the National Academy of Sciences, USA. 79, 2554-2558. (1982)
• [17] John J. Hopfield and D. W. Tank. Neural Computation of Decisions in Optimization Problems. Biological Cybernetics. 52, 141-152. Springer Verlag (1985)
• [18] John J. Hopfield. Pattern recognition computation using action potential timing for stimulus representation. Nature. 376, 33-36. (1995)
• [19] Paul Kocher, Joshua Jaffe and Benjamin Jun. Advances in Cryptology—Crypto 99 Proceedings. Lecture Notes in Computer Science Volume 1666, M. Weiner, edited, Springer-Verlag (1999)
• [20] Harry R. Lewis and Christos H. Papadimitriou. Elements Of The Theory Of Computation. 222-223. Prentice-Hall (1981)
• [21] Yuri Manin. A Course in Mathematical Logic. Springer Verlag (1977)
• [22] Yuri Manin. Computable and Uncomputable (in Russian). Moscow, Sovetskoye Radio (1980)
• [23] Warren S. McCulloch, Walter Pitts. A logical calculus immanent in nervous activity. Bulletin of Mathematical Biophysics. 5, 115-133. (1943)
• [24] Marvin Minsky. Computation: Finite and Infinite Machines (1st edition). Englewood Cliffs, NJ. Prentice-Hall, Inc, (1967)
• [25] Marvin L. Minsky and Seymour A. Papert. Perceptrons. Cambridge, MA. MIT Press, (1969)
• [26] Abraham Robinson. Non-standard Analysis. Revised Edition. Princeton, NJ. Princeton University Press, (1996)
• [27] Frank Rosenblatt. Two theorems of statistical separability in the perceptron. Proceedings of a Symposium on the Mechanization of Thought Processes, Her Majesty's Stationary Office, London, 421M56 (1959)
• [28], Alfred A. Schmitt. The State Complexity of Turing Machines. Information and Control. 17, 1970, pp. 217-225.
• [29] Claude Shannon. Communication Theory of Secrecy Systems. netlab.cs.edu/wiki/fdes/shannon1949.pdf. (1949)
• [30] Peter W. Shor. Algorithms for quantum computation: discrete log and factoring. Proceedings of the 35th Annual IEEE Symposium on Foundations of Computer Science. 2-22 (1994)
• [31] Andre Stefanov, Nicolas Gisin, Olivier Guinnard, Laurent Guinnard and Hugo Zbinden. Optical quantum random number generator. Journal of Modern Optics. 1362-3044, 47, 4, 595-598 (2000) http://arxw.org/pdf/quant-ph/9907006
• [32] H. E. Sturgis, and J. C. Shepherdson. Computability of Recursive Functions. J. Assoc. Comput. Mach. 10, 217-255 (1963)
• [33] Alan M. Turing. On computable numbers, with an application to the Entscheidungsproblem. Proc. London Math. Soc. Series 2 42 (Parts 3 and 4), 230-265 (1936). A correction, ibid. 43, 544-546 (1937).
• [34] Michael Wahl, Matthias Leifgen, Michael Berlin, Tino Rohlicke, Hans-Jurgen Rahn, and Oliver Benson. An ultrafast quantum random number generator with provably bounded output bias based on photon arrival time measurements. Applied Physics Letters. 98, 171105, 2011.
• [35] Jie Yang, Jinlu Liu, Qi Su, Zhengyu Li, Fan Fan, Bingjie Xu and Hong Guo. A 5.4 Gbps real time quantum random number generator with compact implementation. Optics Express. 24(24), 2016, pp. 27475-27481.
• [36] David A. Patterson and John L. Hennessy. Computer Architecture: A Quantitative Approach. 5th Edition, Morgan Kaufmann, 2011.

Claims

1. A machine implemented method for performing computations comprising: constructing a procedure;constructing a first method of a multiplicity of possible methods for a first instance of the procedure;performing computations using the first instance of the procedure;constructing a second method of the multiplicity of possible methods for computing a second instance of the procedure, wherein the first instance of the procedure and the second instance of the procedure implement a same task; andperforming computations using the second instance of the procedure,wherein an unpredictable process generates the first instance of the procedure and the second instance of the procedure by adding unpredictability to the first instance of the procedure and the second instance of the procedure by measuring a physical process that is non-deterministic to create the unpredictability.

2. The machine implemented method of claim 1, wherein said procedure is implemented with digital computer instructions.

3. The machine implemented method of claim 1, wherein said physical process is generated from quantum events.

4. The machine implemented method of claim 3, wherein said quantum events involve emission and detection of photons.

5. The machine implemented method of claim 4, wherein said detection of photons uses the arrival times of photons to generate randomness in said unpredictable process.

6. The machine implemented method of claim 3, wherein said quantum events are generated from particles with spin.

7. The machine implemented method of claim 2, wherein said digital computer instructions execute edge pattern substitution.

8. The machine implemented method of claim 1, wherein said procedure is implemented with a digital computer program.

9. The machine implemented method of claim 8, wherein said digital computer program contains instructions that are expressed in one or more of the following languages: C, C++, Fortran, Go, JAVA, Haskell, LISP, Python, Ruby, assembly language, RISC machine instructions, JAVA virtual machine, prime directed edge sequences, or standard instructions.

10. A machine implemented method for performing computations comprising: constructing a procedure;constructing a first method of a multiplicity of possible methods for a first instance of the procedure;performing computations using the first instance of the procedure;constructing a second method of the multiplicity of possible methods for computing a second instance of the procedure, wherein the first instance of the procedure and the second instance of the procedure implement a same task; andperforming computations using the second instance of the procedure,wherein an unpredictable process generates the first instance of the procedure and the second instance of the procedure by adding unpredictability to the first instance of the procedure and the second instance of the procedure by using instructions that are self-modifying to construct the first instance of the procedure and the second instance of the procedure.

11. A system for performing computations comprising: a processor;a memory storing computer-readable instructions that, when executed by the processor, causes the processor to perform operations comprising: constructing a computational procedure;constructing a first computation, from a multiplicity of possible machine instructions for computing the computational procedure, producing a first instance of the computational procedure;performing computations using the first instance of the computational procedure;constructing a second computation, from the multiplicity of possible machine instructions for computing the computational procedure, producing a second instance of the computational procedure, wherein the first instance of the computational procedure and the second instance of the computational procedure implement a same task; andperforming computations using the second instance of the computational procedure,wherein an unpredictable process generates the first instance of the computational procedure and the second instance of the computational procedure by adding unpredictability to the first instance of the procedure and the second instance of the procedure, and wherein instructions that perform self-modification create the unpredictability.

12. The system of claim 11, wherein the self-modification used in said constructing the computational procedure increases a number of states.

13. The system of claim 11, wherein said first instance of the computational procedure is constructed with digital computer instructions.

14. The system of claim 11, wherein said second instance of the computational procedure is implemented with digital computer instructions.

15. The system of claim 14, wherein said digital computer instructions are expressed in one or more of the following languages: C, C++, Fortran, JAVA, Go, Haskell, LISP, Python, Ruby, assembly language, RISC machine instructions, JAVA virtual machine instructions, or prime directed edge sequences.

16. The system of claim 11, wherein a non-deterministic process generates the first instance of the computational procedure and the second instance of the computational procedure.

17. The system of claim 16, wherein the non-deterministic process measures quantum events.

18. The system of claim 17, wherein the quantum events are measurements of photons.

19. The system of claim 17, wherein the quantum events are generated from particles with spin.

20. The system of claim 17, wherein the quantum events are spin measurements.

21. The system of claim 11, wherein said first instance of the computational procedure computes edge pattern substitution.

22. A machine implemented method for performing computations comprising: constructing a procedure;constructing a first method of a multiplicity of possible methods for a first instance of the procedure;performing computations using the first instance of the procedure;constructing a second method of the multiplicity of possible methods for computing a second instance of the procedure, wherein the first instance of the procedure and the second instance of the procedure implement a same task; andperforming computations using the second instance of the procedure,wherein an unpredictable process generates the first instance of the procedure and the second instance of the procedure by adding unpredictability to the first instance of the procedure and the second instance of the procedure by using a non-deterministic process to construct the first instance of the procedure and the second instance of the procedure.

23. The machine implemented method of claim 22, wherein measurement of quantum events implement the non-deterministic process.

24. A system for performing computations comprising: a processor;a memory storing computer-readable instructions that, when executed by the processor, causes the processor to perform operations comprising: constructing a computational procedure;constructing a first computation, from a multiplicity of possible machine instructions for computing the computational procedure, producing a first instance of the computational procedure;performing computations using the first instance of the computational procedure;constructing a second computation, from the multiplicity of possible machine instructions for computing the computational procedure, producing a second instance of the computational procedure, wherein the first instance of the computational procedure and the second instance of the computational procedure implement a same task; andperforming computations using the second instance of the computational procedure,wherein an unpredictable process generates the first instance of the computational procedure and the second instance of the computational procedure by adding unpredictability to the first instance of the computational procedure and the second instance of the computational procedure by using a non-deterministic process to construct the first instance of the computational procedure and the second instance of the computational procedure.

25. The system of claim 24, wherein measurement of quantum events implement the non-deterministic process.