Quantum random, self-modifiable computer

Abstract

We describe a computing machine, called an ex-machine, that uses self-modification and randomness to enhance the computation. The name ex-machine is derived from the latin extra machinam because its can evolve as it computes so that its complexity increases without an upper bound. In an embodiment, an ex-machine program can compute languages that a Turing or standard machine cannot compute. In an embodiment, the ex-machine has three types of instructions: standard instructions, meta instructions and random instructions. In an embodiment, the meta instruction self-modify the machine as it is executing so that new instructions are added. In an embodiment, the standard instructions are expressed in the C programming language or VHDL dataflow language. Random instructions take random measurements from a random source. In an embodiment, the random source produces quantum events which are measured.

Description

2 FIELD

The specification generally relates to computing: computing hardware, random number generation in computation, random instructions, machine-implemented methods, machine-implemented systems, and self-modification of programs and hardware.

3 ADVANTAGES OVER THE PRIOR ART

Consider two fundamental questions in computer science, which substantially 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 is the basis for the famous PNP problem [10].

In the prior art, the two questions are typically conceived and implemented with hardware and software that compute according to the Turing machine (TM) [24] (i.e., standard digital computer [17]) model, which is the standard model of computation [5, 6, 10, 15, 23] in the prior art.

In this invention(s), our embodiments advance far beyond the prior art, by applying new machine-implemented methods and new hardware to advance computation and in particular, machine learning and the computation of program correctness for standard digital computer programs. The machine embodiments bifurcate the first question into two questions. What is computation? What can computation compute? Our new computing machine adds two special types of instructions to the standard digital computer [17] instructions 110, as shown in FIG. 1A. Some embodiments are referred to as an ex-machine—derived from the latin extra machinam—because ex-machine computation generates new dynamical behaviors and computational capabilities that one may no longer recognize as a standard digital computer or typical machine.

One type of special machine instruction is meta instruction 120FIG. 1A. In some embodiments, meta instructions 120 help make up self-modifiable system 250, shown in FIG. 2B. 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 [19, 20] of an ex-machine to increase.

The other special instruction is a random instruction 140 in FIG. 1A that can be physically realized with random measurements 130. In some embodiments, a light emitting diode, shown in FIG. 5A, FIG. 5B, and FIG. 5C emits photons that random measurements 130 detect. In other embodiments, random instruction 140 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, or protein folding. Due to random instructions 140, 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 120, 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 machine learning applications and cryptographic computations. This property makes it more challenging for an adversary to attack or tamper with the computation. This property enables ex-machine programs to evolve new machine learning procedures.

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 machine learning applications, cryptographic computation, and for verifying program correctness in standard digital computer programs. 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 the disclosure of these inventions, a countable set of ex-machines are explicitly specified, using standard instructions, meta instructions and random instructions. Using the mathematics of probability, measure theory and Cantor's heirarchy of infinities, we prove that every one of these ex-machines can evolve to compute a Turing incomputable language with probability measure 1, whenever random measurements 130 (trials) behave like unbiased Bernoulli trials. (A Turing machine [24] or digital computer [17] cannot compute a Turing incomputable language.) For this reason, when we discuss to computational methods in the prior art, we will refer to a Turing machine program or digital computer program as an algorithm. Since the mechanical rules of an algorithm are fixed throughout the computation and the complexity of an algorithm stays constant during all executions of an algorithm, we will never refer to an ex-machine computation as an algorithm. Overall, the mathematics presented herein shows that the ex-machine inventions advance far beyond the prior art.

4 DESCRIPTION of FIGURES

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. 1A shows an embodiment of an ex-machine comprised of machine instructions 110 (composed of standard instructions 110, random instructions 140 and meta instructions 120), random measurements 130, memory 116, memory values 118 and machine states 114.

FIG. 1B shows an embodiment of a random instructions 150 comprised of random generator 160 that measures one or more quantum events 170.

FIG. 1C shows an embodiment of a meta instruction 120 executing (FIG. 1A). In FIG. 1C, while executing, meta instruction (5, 0, |Q|−1, 1, 0, J) creates a new standard instruction J=(7, 1, 8, #, −1).

FIG. 1D shows an embodiment of a meta instruction, where the new standard instruction J=(7, 1, 8, #, −1) is executed right after it is created in FIG. 1C.

FIG. 2A shows an embodiment of a computer network, implemented with ex-machines. In some embodiments, the transmission may be over the Internet or a part of a network that supports an infrastructure such as the electrical grid, a financial exchange, or a power plant.

FIG. 2B shows an embodiment of a computing architecture that implements an ex-machine, which includes a processor, memory and input/output system, random system, and self-modification system. This embodiment may be the ex-machine of FIG. 1A.

FIG. 3 shows a graphic representation of an infinite binary tree. This figure helps visualize why ex-machines, such as (x) and others, can compute languages that standard machines are unable to compute.

FIG. 4 shows a mobile smartphone embodiment 400 that computes wireless voice data and communicates wireless voice data, which may include the machine instructions of FIG. 1A. The mobile phone 500 is an embodiment that contains an ex-machine that intelligently sends secure commands and keys to control an automobile.

FIG. 5A shows an embodiment of a randomness generator, based on quantum randomness. The ex-machine instructions, described in definition 5.2, use this generator as a source of quantum randomness. Randomness generator 542 is based on the behavior of photons to measure randomness. Randomness generator 542 contains a light emitting diode 546 that emits photons and a phototransistor 544 that absorbs and detects photons.

FIG. 5B shows an embodiment of a randomness generator, based on quantum randomness. Randomness generator 552 is based on the behavior of photons to take random measurements. Randomness generator 552 contains a light emitting diode 556 that emits photons and a phototdiode 554 that absorbs and detects photons.

FIG. 5C shows an embodiment of random measurements 130, that uses quantum events 565 to provide a spin-1 source 560; followed by an S_z beam splitter 570; and then followed by a S_x beam splitter 580 that produces a random binary outcome. In an embodiment, electrons act as a spin-1 source.

FIG. 6A shows a light emitting diode, which emits photons and in some embodiments is part of the random number generator. The light emitting diode contains a cathode, a diode, an anode, one terminal pin connected to the cathode and one terminal pin connected to the anode, a p-layer of semiconductor, an active region, an n-layer of semiconductor, a substrate and a transparent plastic case.

FIG. 6B shows a light emitting diode, containing a semiconductor chip.

FIG. 6C shows a light emitting diode, showing a semiconductor view of the light emitting diode, and including electron and hole flow based on the conduction and valence bands.

FIG. 7A shows a standard machine configuration in machine state q and the contents of its memory in a sequential representation before a standard machine instruction is executed. The purpose is to see how to transform instructions to geometric maps.

FIG. 7B shows a standard machine configuration in machine state r and its memory contents in a sequential representation after a standard machine instruction is executed.

FIG. 7C shows a standard machine configuration in machine state r and its memory contents in a sequential representation after a standard machine instruction is executed.

FIG. 7D shows right affine map 740 that corresponds to the instruction (q, T_k, r, b, +1) executed by a digital computer in FIG. 7B. The right affine map is

$f\left(x+\mathrm{yi}\right)=f_1\left(x\right)+f_2\left(y\right)i,\mathrm{where}\text{}{f}_1\left(x\right)=f_1\left(x\right)=❘A❘x+\left(❘A❘-1\right)v\left(T_{k+1}\right)-{❘A❘}^{2}v\left(T_k\right)\mathrm{and}{f}_2\left(x\right)=\frac{1}{❘A❘}y+\mathrm{Bv}\left(r\right)+v\left(b\right)-\frac{B}{❘A❘}v\left(q\right).$ f is described further in section 9, titled The ϕ Correspondence.

FIG. 7E shows left affine map 760 that corresponds to the instruction (q, T_k, r, b, −1) executed by a digital computer in FIG. 7C. The left affine map is

$g\left(x+yi\right)=g_1\left(x\right)+g_2\left(y\right)i,\mathrm{where}{g}_1\left(x\right)=\frac{1}{❘A❘}x+❘A❘v\left(T_{k-1}\right)+v\left(b\right)-v\left(T_k\right)\mathrm{and}\text{}{g}_2\left(y\right)=❘A❘y+Bv\left(r\right)-❘A❘Bv\left(q\right)-❘A❘v\left(T_{k-1}\right).$ g is described further in section 9, titled The ϕ Correspondence.

FIG. 8A shows a piecewise linear approximation of sigmoid function

$g\left(x\right)=\frac{2}{\pi }\arctan \left(x\right).$ Sigmoid functions are used in machine learning embodiments (FIG. 9A) that execute meta instructions and random instructions. There are 17 points in this piecewise linear approximation: (−13, −0.95), (−8.5, −0.93), (−6.25, −0.9), (−4.15, −0.85), (−3.05, −0.8), (−2.4, −0.75), (−1.38, −0.6), (−1, −0.5), (−0.5, −0.3), (0, 0), (0.5, 0.3), (1, 0.5), (1.38, 0.6), (2.4, 0.75), (3.05, 0.8), (4.15, 0.85), (6.25, 0.9), (8.5, 0.93), (13, 0.95).

FIG. 8B shows a piecewise linear approximation of the almost step function x(x)=e^−(2x)20. There are 17 points in this piecewise linear approximation: (−0.6, 0), (−0.54, 0.01), (−0.55, 0.001), (−0.53, 0.04), (−0.52, 0.1), (−0.5, 0.35), (−0.45, 0.9), (−0.4, 1), (0, 1), (0.4, 1), (0.45, 0.9), (0.5, 0.35), (0.52, 0.1), (0.53, 0.04), (0.54, 0.01), (0.55, 0.001), (0.6, 0). Almost step functions are used in machine learning embodiments (FIG. 9A) that execute meta instructions and random instructions.

FIG. 8C shows a network of sigmoidal functions that are used in machine learning embodiments. Some embodiments have 2 or 3 layers of sigmoidal functions connected by linearly weighted sums. Some embodiments have 100 layers of sigmoidal functions. Some embodiments have more than ten thousand layers of sigmoidal functions. Some embodiments have more than one million layers of sigmoidal functions.

FIG. 8D shows a network of sigmoidal and almost steps functions that are used in machine learning embodiments. Some embodiments have 2 or 3 layers of sigmoidal functions connected by linearly weighted sums. Some embodiments have 100 layers of sigmoidal and almost step functions. Some embodiments have more than ten thousand layers of sigmoidal and almost step functions. Some embodiments have more than one million layers of sigmoidal and almost step functions.

FIG. 8E shows a multi-layer network of nonlinear functions, used in machine learning procedure 9A. In an embodiment, the inputs of node function are weighted sums of the functions from the previous layer.

FIG. 9A shows a non-algorithmic machine learning procedure with machine instructions 900, containing random instructions 920, meta instructions 930 and standard instructions 940. The machine learning procedure is initially machine learning procedure 910. The random instructions 920 and meta instructions 930 enable the initial machine learning procedure 910 to self-modify while computing to Evolving Machine Learning procedure 950.

5 Ex-Machine Computer

Our invention describes a quantum random, self-modifiable computer that adds two special types of instructions to standard digital computer instructions [5, 10, 14, 15, 17, 24]. 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 machine states 114 in FIG. 1A. This convenient representation of the ex-machine states 114 helps specify how new machine states are added to Q when a meta instruction 120 is executed. An example of meta instruction execution is shown in FIG. 1C and FIG. 1D where machine state 8 is added to machine states 114 after execution of the first meta instruction (step 1).

Let ={a₁, . . . , a_n}, where each a_i represents a distinct memory value 118 stored in memory 116, represented as T. The set A={0, 1, #}∪ consists of alphabet symbols (memory values), where # is the blank symbol and {0, 1, #}∩ is the empty set. In some ex-machines, A={0, 1, #, Y, N, a}, where a₁≠Y, a₂=N, a₃=a. In some ex-machines, A={0, 1, #}, where is the empty set. The memory values are read from and written to memory (T). The ex-machine memory 116 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 or non-existent memory values, except for a finite number of memory addresses. When this condition holds for memory 116, we say that memory T is finitely bounded.

5.1 Standard Instructions

Machine Specification 5.1

Execution of Standard Instructions 110 in FIG. 1A

The standard ex-machine instructions S satisfy S⊂Q×A×Q×A×{−1, 0, 1} and a uniqueness condition: If (q₁, α₁, r₁, a₁, y₁)∈S and (q₂, α₂, r₂, a₂, y₂)∈S and (q₁, α₁, r₁, a₁, y₁)≠(q₂, α₂, 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 memory value 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 memory value 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 memory value T(k)=α at memory address k.

In other embodiments, standard instructions 110 in FIG. 1A may be expressed with C syntax such as x=x+1; or z=(x+1)*y. In some embodiments, one of the standard instructions 110 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 140 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 110 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. 2A. In other embodiments, the standard instructions 110 may read hex memory address 0x54E9A701285674FB41DEC7406382936A and after one instruction is executed, during the second computational step the instruction may read hex memory address 0x9A2368895EDC0523415E8790738293B8: random access memory is available in memory system 246 of FIG. 2B. In some embodiments, random access of memory is also implied by the fact that the standard instructions 110 may have a programming language syntax such as assembly language, C++, Fortran, JAVA, JAVA virtual machine instructions, Go, Haskell, RISC machine instructions, Ruby, LISP, or a hardware dataflow language such as VHDL [25].

A digital computer program [17] or a Turing machine [24] 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 5.1. In other words, an ex-machine that uses only standard instructions is computationally equivalent to a digital computer [17]. 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

Repeated independent trials are called random Bernoulli trials [9] if there are only two possible outcomes for each trial (i.e., random measurement 130 in FIG. 130) and the probability of each outcome remains constant for all trials. In an embodiment, the outcome is a result of measuring quantum event 170, quantum event 547, quantum event 557, or quantum event 565. 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 . 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_i 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 randomness generator 160 used by random instructions 140, 150 has measurement properties 1 and 2. In some embodiments, randomness generator 542 in FIG. 5A has measurement properties 1 and 2. In other embodiments, physical devices that are built with quantum observables according to FIG. 5C exhibit properties 1 and 2 when measurements are taken by the physical device. In some embodiments, electrons may provide the spin-1 source of a quantum event 565, as shown in FIG. 5C. In some embodiments, photons in LED 610 in FIG. 6A, or LED 620 in FIG. 6B, or LED 630 in 6C. may provide a source of quantum events 170, 547 or 557 that are measured by random measurements 130 and detected by phototransistor 544 or photodiode 554. Section 6 provides a physical basis for the measurement properties and a discussion of quantum randomness for some embodiments of non-determinism.

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 5.2

Execution of Random Instructions 140 in FIG. 1A

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 memory value a from memory T and the machine is in machine state q, the random instruction (q, a, r, y) executes as follows:

1. The machine reads random measurements 130 that returns a random bit b∈{0, 1}.

2. In memory, memory value a is replaced with random bit b.

• • (This is why A contains both symbols 0 and 1.)

3. The machine state changes to machine state r.

4. The machine moves its memory head left if y=−1, right if y=+1, or the memory head does not move if y=0.

In some embodiments, the source of non-determinism in random measurements 130 is a quantum event 170. In some embodiments, quantum event 170 is generated outside of the hardware of the ex-machine: for example, the arrival of a photon from the environment outside of the ex-machine, as shown in quantum event 547. These photons may arrive from our sun, or an external light build or by an LED 610, LED 620, or LED 630, mounted on a circuit board, outside the processor that executes the ex-machine. In an embodiment, LED 610 or LED 620 or more than one LED is mounted on a circuit board; phototransistor 544 or may be photodiode 554 may be mounted so that the photosensitive part of the semiconductor is facing LED 610 or LED 620. In another embodiment, quantum event 170 is generated by semiconductor LED 630, inside of the hardware that implements processor system 252 of the ex-machine; in an embodiment, semiconductor LED 630 is integrated into a semiconductor chip that implements processor system 252.

In some embodiments, quantum measurements satisfy random measurement property 1 and random measurement property 2. In some embodiments, random measurements 130 is implemented with randomness generator 542 in FIG. 5A. In some embodiments, quantum random measurements 130 measure quantum events 565, using a spin-1 source 560 (e.g., electrons), followed by a S_z splitter 570 and then a S_x splitter 580 as shown in FIG. 5C. In some embodiments, photons in LED 610 in FIG. 6A, or LED 620 in FIG. 6B, or LED 630 in 6C. may provide a source of a quantum event 547 or quantum 557, that are measured by random measurements 130, which uses phototransistor 544 or photodiode 554 as a detector of a quantum event. In some embodiments, phototransistor 544 of FIG. 5A may measure the arrival time of one or more photons as a part of semiconductor chip that comprises randomness generator 542. In an embodiment, quantum event

In some embodiments, there are more than two outcomes of taking the physical measurement by random measurements 130. For example, 8 different outcomes can be generated by repeating 3 measurements with spin-1 source 560 (e.g., electrons), followed by a S_z splitter 570 and then a S_x splitter 580 as shown in FIG. 5C. These three measurements produce 3 bits, which represent 2³=8 possible outcomes. In an embodiment, there are three outcomes. In another embodiment, there are four different outcomes.

In an embodiment, after execution of a random instruction, at step 4, the machine may random access to a different part of memory. For example, before a random instruction is being executed, it may be reading memory address 0x4B6368895EDC0543418E8790738293B9 and after at step 4, it moves to reading memory address 0x29F2B761285674FB41DE074063529462.

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 Specification 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), as a part of random instructions 140 in FIG. 1A. In random measurements 130, the measuring device 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, 1_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, 1_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. As a part of random instructions 140 in FIG. 1A, the first random instruction executed is (0, #, 0, 0). Measured by random measurements 130, the random bit 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, 1_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 a standard machine or a digital computer, 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, which enhances its computational capabilities.

Meta Instructions

Meta instructions are a second type of special instructions, as shown in 120 of FIG. 1A. 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 while ex-machine instructions 100 of FIG. 1A are being executed. Formally, the meta instructions satisfy ⊂{(q, a, r, α, y, J): q∈Q and r∈Q∪{|Q|} and a, α∈A and instruction J∈S∪} as a part of self-modification system 250 (FIG. 2B) while executing in processor system 252. In an embodiment, processor system 252 is implemented in machines 204, 214, 216, 218, 220 of FIG. 2A.

Define =S∪∪, as the set of standard 110, random 140, and meta instructions 120 in FIG. 1A, stored in memory system 246 (FIG. 2B). To help describe how a meta instruction modifies in self-modification system 250 of FIG. 2B, the unique state, scanning symbol condition is defined. For any two distinct instructions chosen from at least one of the first two coordinates should differ so that processor system 252 in FIG. 2B can determine which machine instruction 100 to execute next. More precisely, all 6 of the following uniqueness conditions hold for the instructions 110, 120 and 140 (FIG. 1A, 1B, 1C, 1D) that are stored in hardware memory system 246.

1. If (q₁, α₁, r₁, β₁, y₁) and (q₂, α₂, r₂, β₂, y₂) are both in S, then q₁≠q₂ or α₁≠α₂.

2. If (q₁, α₁, r₁, β₁, y₁)∈S 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₁)∈S 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. 2B, should be designed so that the standard, quantum random and meta instructions S∪∪ 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 5.3 is an embodiment of self-modification system 250 in FIG. 2B. Specification 5.3 is also an embodiment of meta instructions 120 in FIG. 1A.

Machine Specification 5.3

Execution of Meta Instructions 120 in FIG. 1A

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 5.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 three forms: J=(q, a, r, α, y) or J=(q, a, r, y) or J=(q, a, r, α, y, J₁). In the third form, J is also a meta instruction.
  • For each of the three 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 the third form, in meta instructions 120 of FIG. 1A, a meta instruction that executes can create a new meta instruction, which is added to or replaces some other instruction that already lies in , according to the unique state, scanning symbol condition. A meta instruction that creates another meta instruction can also be part of self-modification system 250. In regard to specification 5.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, 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. 1C 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, α₁=1, y₁=0, a₂=1, α₂=#, and y₂=1. States and alphabet symbols are shown in red and blue, respectively. FIG. 1D shows the execution of the second computational step for meta instruction (q, a₁, |Q|−1, α₁,y₁, J), where J=(|Q|−1, α₂,|Q|, α₂, y₂). FIG. 1C and FIG. 1D illustrate how new machine states are added to Q, as a result of executing the meta instruction.

In other embodiments, meta instructions 120 in FIG. 1A 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 machine states. In hardware, extra instructions created by the execution of a meta instruction can be stored in this hardware, implementing memory system 246 of FIG. 2B. In other embodiments, meta instructions 120 in FIG. 1A may be implemented in a more abstract programming language. In some embodiments, meta instructions 120 can be implemented the LISP programming language and executed on computing machine 204, shown in FIG. 2A with an external random number generator 552 in FIG. 5B with LEDs as the quantum sources, as shown in FIG. 6A, FIG. 6B and FIG. 6C. In another embodiment, randomness generator 552 may be part of an integrated circuit that also executes machine instructions 100, including standard instructions 110, meta instructions 120 and random instructions 140.

Below is an example of how meta instructions 120 in FIG. 1A 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 FIG. 1C) 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 5.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|−c₂ 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.

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

With an initial blank memory and starting state of 0, the first four computational steps are shown below. In the first step, 's 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 IN-
STATE	MEMORY	ADDRESS	INSTRUCTION	STRUCTION
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 (|Q|−1, 1, |Q|, 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 (|Q|−1, #, |Q|−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 (|Q|−1, 1, |Q|, 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 5.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 hardware embodiments of FIG. 1A, FIG. 2A, FIG. 2B, FIG. 5A, FIG. 5B, FIG. 5C, FIG. 6A, FIG. 6B, FIG. 6C, before the machine starts its execution.

1. The number of machine states |Q| is finite.

2. The number of alphabet symbols |A| (i.e., memory values) 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 5.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, quantum computers that use entanglement and quantum superposition.

Remark 5.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 5.5 of finite initial conditions and machine instruction specifications 5.1, 5.2, and 5.3. In particular, the execution of one meta instruction adds at most one new instruction and one new state to Q.

Specification 5.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 140 and meta instructions 120 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 ₀ with memory T₀ evolves to ex-machine ₁ with memory S₁.

Machine Specification 5.6

Evolving an Ex-Machine

Let T₀, T₁, T₂ . . . T_i−1 each be a finitely bounded memory. Consider ex-machine ₀ 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 _i with memory S_i. One says that ex-machine ₀ with finitely bounded memories T₀, T₁, T₂ . . . T_i−1 evolves to ex-machine _i 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. 2A. In an embodiment, token 202 may contain hardware shown in FIG. 5A, FIG. 5B, FIG. 5C, FIG. 6A, FIG. 6B, or FIG. 6C. Token 202 may provide quantum random measurements 130 or help implement random instructions 150 in FIG. 1B that are used by machines 214, 216, 218 and 220 of FIG. 2A.

6 Non-Determinism, Randomness, and Quantum Events

In some embodiments, the computing machines described in this invention use non-determinism 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, based on measuring quantum events 170 by randomness generator 160, as shown in FIG. 1B. We ran DIEHARD statistical tests of our random instructions executed in Random Walk Embodiment 1, whose implementation follows embodiments shown in FIG. 6A, FIG. 6B and FIG. 6C. The statistics of our random instructions executed in Random Walk Embodiment 1 behave according to random measurement properties 1 and 2. These statistical properties have also been empirically observed in other quantum random sources [22, 26, 27].

Some embodiments of physically non-deterministic processes are as follows. In some embodiments that utilize non-determinism, photons can (i.e., quantum event 170, quantum event 547, quantum event 557) strike a semitransparent mirror and then take two or more paths in space. In one embodiment, if the photon is reflected by the semitransparent mirror, then it takes on one bit value b with a binary outcome: if the photon passes through by the semitransparent mirror (i.e., quantum event 170), then the non-deterministic process produces another bit value 1b.

In another embodiment, the spin 560 of an electron may be measured to generate the next non-deterministic bit. In another embodiment, a protein, composed of amino acids, spanning a cell membrane or artificial membrane, that has two or more conformations (quantum event 170 in FIG. 1B) can be used to detect non-determinism: the protein conformation (quantum event 170) measured by random measurements 130 can generate a non-deterministic value in {0, 1, n1}, 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 (quantum event 170 in FIG. 1B) and the differences of 3 arrival times t₀<t₁<t₂ could generate non-deterministic bits: generate 1 if t₂−t₁>t₁−t₀ and generate 0 if t₂−t₁<t₁−t₀ and do not generate a bit if t₂−t₁=t₁−t₀ In some embodiments, a Geiger counter may measure the detection of radioactive events (quantum event 170) as a part of randomness generator 160 that is a part of random instructions 150.

In sections 7 and 12, 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. In an embodiments, where the probability of one binary outcome is p≠½, then an unbiased source of randomness (i.e., each binary string is equally likely) can be produced with a simple standard machine that operates on more than one measurement of the binary outcome to produce a single, unbiased outcome. The number of measurements, taken by random measurements 130, needed to generated an unbiased binary outcome, depends upon how far p is from frac12.

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. In [9], Feller 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 111.5 of [9].

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 2, 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 [4, 13] 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 _z. 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.

6.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 [7] that randomness is unpredictability, 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 f:→, where f(x)=9/2x(1−x). Set I₀=[0, ⅓] and I₁=[⅓, ⅔]. Set B=(⅓, ⅓). Define the set Λ={x∈[0, 1]: fⁿ (x)∈I₀∪I₁ for all n∈}. 0 is a ∪fixed point of f and f²(⅓)=f²(⅔)=0, so the boundary points of B lie in Λ. Furthermore, whenever x∈B, then

$f\left(x\right)<0\mathrm{and}\underset{n\to \infty }{\lim }{f}^n\left(x\right)=-\infty .$ This means all orbits that exit Λ head off to −∞.

The inverse image f⁻¹(B) is two open intervals B₀⊂I₀ and B₁⊂I₁ such that f(B₀)=f(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 Σ₂=. 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 fⁿ(x)∈I₀ and a_n=1 if fⁿ(x)∈I₁.

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

$d\left(\left(a_0{a}_1\dots \right),\left(b_0{b}_1\dots \right)\right)=\sum _{i=0}^{\infty }❘a_i-b_i❘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∘f=σ∘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 [3] Similarly, at the second observation, our observer measures a 0 if f(x) lies in I₀ and 1 if f(x) lies in I_l. Our observer continues to make these observations until she has measured whether F⁻¹ (x) is in I₀ or in I₁. Before making her k+1st observation, can our observer make an effective prediction whether f^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 [9]) 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 f is mathematically deterministic and f is a Turing computable function.

Overall, the dynamical system (f, Λ) 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.

6.2 Quantum Random Theory

The standard theory of quantum randomness stems from the seminal EPR paper [8]. Einstein, Podolsky and Rosen (EPR) 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 [2], 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 displaced. 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 130 in FIG. depend upon Kochen-Specker type theorems [4, 13] In some embodiments, the unpredictability of random measurements 130 in FIG. 1A depend upon Bell type theorems [1].

In an embodiment of quantum random measurements 130 shown in FIG. 1A, a protocol for two sequential measurements that start with a spin-1 source is shown in FIG. 5C. 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_z=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.

7 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 2. 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\subset \left\{a\right\}*}\left\{L\right\}.$ Machine Specification 7.1 defines a unique language in for each function f: N→{0,1}.

Machine Specification 7.1

Language L_f

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

Trivially, L_f is a language in . Moreover, these functions f generate all of .

Remark 7.1

$ℒ=\bigcup _{f\in {\left\{0,1\right\}}^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 7.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 aⁿ 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 [14].

For a particular string # #a^m#, some ex-machine 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 7.2. These types of ex-machines will not be specified in this invention.

There is a subtle difference between (x) and an ex-machine 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 7.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 aⁿ to a binary string in {0, 1}* as follows. The empty string in {a}* maps to the empty string in {0,1}*. Let 0 represent this translation map. Hence,

$a\stackrel{\psi }{\to }0,\mathrm{aa}\stackrel{\psi }{\to }1,\mathrm{aaa}\stackrel{\psi }{\to }00,a^4\stackrel{\psi }{\to }01,a^5\stackrel{\psi }{\to }10,a^6\stackrel{\psi }{\to }11,a^7\stackrel{\psi }{\to }000,$ and so on. Similarly, an inverse translation standard machine computes the inverse of ψ. Hence

$0\stackrel{{\psi }^{-1}}{\to }a,1\stackrel{{\psi }^{-1}}{\to }\mathrm{aa},00\stackrel{{\psi }^{-1}}{\to }$ aaa, wild 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 7.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 two quantum random instructions satisfy property 1 (unbiased bernoulli trials) and random measurement 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 [9] for a comprehensive study of random walks.)

Moreover, there is a one-to-one correspondence between a function f:→{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 f:→{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_f in when quantum random instructions #, x, 0) and (x, a, t, 0) satisfy random measurement property 1 and random measurement property 2.

Machine Specification 2

(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, (|Q|−1, #, n, #, 1))
  • (x, 1, w, #, 0, (|Q|−1, #, y, #, 1))
  • (t, 0, w, a, 0, (|Q|−1, #, n, #, 1))
  • (t, 1, w, a, 0, (|Q|−1, #, y, #, 1))
  • (v, #, n, #, 1, (|Q|−1, a, |Q|, a, 1))
  • (w, #, y, #, 1, (|Q|−1, a, |Q|, a, 1))
  • (w, a, |Q|, a, 1, (|Q|−1, a, |Q|, a, 1))
  • (|Q|−1, a, x, a, 0)
  • (|Q|−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, (|Q| − 1, #, y, #, 1))	(8, #, y, #, 1)
9	##a aaa###	2	(w, a, |Q|, a, 1, (|Q| − 1, a, |Q|, 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, (|Q| − 1, #, y, #, 1))	(9, #, y, #, 1)
10	##aa aa###	3	(w, a, |Q|, a, 1, (|Q| − 1, a, |Q|, 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, (|Q| − 1, #, n, #, 1))	(10, #, n, #, 1)
11	##aaa a###	4	(w, a, |Q|, a, 1, (|Q| − 1, a, |Q|, 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, (|Q| − 1, #, y, #, 1))	(11, #, y, #, 1)
12	##aaaa ###	5	(w, a, |Q|, a, 1, (|Q| − 1, a, |Q|, 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, (|Q| − 1, #, n, #, 1))	(12, #, n, #, 1)
n	##aaaa# ##	6	(v, #, n, #, 1, (|Q| − 1, a, |Q|, 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, |Q|, a, 1, (|Q|−1, a, |Q|, a, 1)) executes and replaces (8, a, x, a, 0) with new instruction (8, a, 9, a, 1). Also, simple meta instruction (|Q|−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 (|Q|−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 1

(11010 x)

• • (0, #, 8, #, 1)
  • (y, #, h, Y, 0)
  • (n, #, h, N, 0)
  • (x, #, x, 0)
  • (x, a, t, 0)
  • (x, 0, v, #, 0, (|Q|−1, #, n, #, 1))
  • (x, 1, w, #, 0, (|Q|−1, #, y, #, 1))
  • (t, 0, w, a, 0, (|Q|−1, #, n, #, 1))
  • (t, 1, w, a, 0, (|Q|−1, #, y, #, 1))
  • (v, #, n, #, 1, (|Q|−1, a, |Q|, a, 1))
  • (w, #, y, #, 1, (|Q|−1, a, |Q|, a, 1))
  • (w, a, |Q|, a, 1, (|Q|−1, a, |Q|, a, 1))
  • (|Q|−1, a, x, a, 0)
  • (|Q|−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, #, y, #, 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 zeroeth, 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 aⁿ 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 ##.

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 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 a⁵ 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 3 specifies (a₀a₁ . . . a_m x) in terms of initial machine states and initial machine instructions.

Machine Specification 3

(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_i 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, (|Q|−1, #, n, #, 1))
  • (x, 1, w, #, 0, (|Q|−1, #, y, #, 1))
  • (t, 0, w, a, 0, (|Q|−1, #, n, #, 1))
  • (t, 1, w, a, 0, (|Q|−1, #, y, #, 1))
  • (v, #, n, #, 1, (|Q|−1, a, |Q|, a, 1))
  • (w, #, y, #, 1, (|Q|−1, a, |Q|, a, 1))
  • (w, a, |Q|, a, 1, (|Q|−1, a, |Q|, a, 1))
  • (|Q|−1, a, x, a, 0)
  • (|Q|−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₇, #, 1)
  • (m+7, a, m+8, a, 1)
  • (m+8, #, b_m+8, #, 1)
  • (m+8, a, m+9, a, 1)

Machine Computation Property 7.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 3. 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, (|Q|−1, #, n, #, 1)) and (w, a, |Q|, a, 1, (|Q|−1, a, |Q|, 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 (|Q|−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 (|Q|−1, #, x, 0).

If the execution of (x, a, t, 0) measures a 1, the two meta instructions (t, 1, w, a, 0, (|Q|−1, #, y, #, 1)) and (w, a, |Q|, a, 1, (|Q|−1, a, |Q|, 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 (|Q|−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 (|Q|−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 (|Q|−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, (|Q|−1, #, n, #, 1)) and (v, #, n, #, (|Q|−1, a, |Q|, a, 1)) are executed. Then the last instruction executed is (a, #, h, N, 0) which indicates that an 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, (|Q|−1, #, 1)) and (w, #, y, #, 1, (|Q|−1, a, |Q|, 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 3, where one substitutes n for m.

Remark 7.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 3, are constructible (i.e., can be printed) with a standard machine.

In contrast with lemma 7.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 7.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_i 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 3 instructions below print the ex-machine instructions for (11010 x), listed in machine instructions 1.

(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{circumflex over ( )}i is in the language.
(make_instruction ″y″ ″#″ ″h″ ″Y″ 0)
;; This means string a{circumflex over ( )}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″ ″v″ ″#″ 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 ″) ″) ) )
(println ″)″) )
(define (print_xmachine x_machine)
(println)
(dolist (instruction x_machine)
(print_instruction instruction))
(println)
)

Machine Specification 7.3

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

$=\left\{\left(x\right)\right\}\bigcup \underset{m=0}{\bigcup ^{\infty }}\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 7.2

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

Proof. The theorem follows from ex-machine 2, ex-machine 3 and lemma 7.1.

Machine Computation Property 7.3

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

Machine Computation Property 7.4

Moreover, for each n, all ex-machines (x), (f(0)x), (f(0)f(1) x), . . . , f(0)f(1) . . . f(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 3.

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 heirarchy of infinities) languages L_f are not computable with a Turing machine. More precisely, the cardinality of the set of languages L_f 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_f: f∈ and f(i)=a_i for i satisfying 0≤i≤n}. Define the corresponding subset of as S(a₀a₁ . . . a_n)={f∈: f(i)=a_i for i satisfying 0≤i≤n}. Let Ψ denote this 1-to-1 correspondence, where

$\stackrel{\Psi }{\leftrightarrow }{\left\{0,1\right\}}^N\mathrm{and}ℒ\left(a_0{a}_1\dots a_n\right)\stackrel{\Psi }{\leftrightarrow }S\left(a_0{a}_1\dots a_n\right).$

Since random measurement property 1 and random measurement property 2 are both satisfied, each finite path f(0)f(1) . . . f(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 . Hence, each subset S(a₀a₁ . . . a_n) has measure 2⁻⁽ⁿ⁺¹⁾. That is, μ(S(a₀a₁ . . . a_n))=2⁻⁽ⁿ⁺¹⁾ and μ()=1. Via the Ψ correspondence between each language tree (a₀a₁ . . . a_n) and subset S(a₀a₁ . . . a_n), uniform probability measure μ induces a uniform probability measure v on , where v(a₀a₁ . . . a_n))=2⁻⁽ⁿ⁺¹⁾ and v()=1.

Theorem 7.5

For functions f:{0, 1}, the probability that language L_f is Turing incomputable has measure 1 in (v,).

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

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

Machine Computation Property 7.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 (v, ). Also, (a₀a₁ . . . a_m x) can evolve to compute Turing incomputable languages on a set of measure 2^−(m+1) with respect to (v, ). 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 .

These corollaries are remarkable because the language that an ex-machine can compute reflects it computing capabilities. This means practical applications that were not possible with digital computer programs are feasible with an ex-machine.

8 The Ex-Machine Halting Problem

In [24], Alan Turing posed the halting problem for Turing machines. Does there exist a Turing machine that can determine for any given Turing machine and finite initial tape T whether 's execution on tape T eventually halts? In the same paper [24], Turing proved that no single Turing machine could solve his halting problem.

Next, we explain what Turing's seminal result relies upon in terms of abstract computational resources. Turing's result means that there does not exist a single Turing machine —regardless of the size of 's finite state set Q and finite alphabet set A—so that when this special machine is presented with any Turing machine with a finite tape T and initial state q₀, then can execute a finite number of computational steps, halt and correctly determine whether halts or does not halt with a tape T and initial state q₀. In terms of definability, the statement of Turing's halting problem ranges over all possible Turing machines and all possible finite tapes. This means: for each tape T and machine , there are finite initial conditions imposed on tape T and machine . However, as tape T and machine range over all possibilities, the computational resources required for tape T and machine are unbounded. Thus, the computational resources required by are unbounded as its input ranges over all finite tapes T and machines .

The previous paragraph provides some observations about Turing's halting problem because any philosophical objection to (x)'s unbounded computational resources during an evolution should also present a similar philosophical objection to Turing's assumptions in his statement and proof of his halting problem. Notice that corollary 7.4 supports our claim.

Since (x) and every other x-machine (a₀a₁ . . . a_m x) in is not a Turing machine, there is a natural extension of Turing's halting problem. Does there exist an x-machine (x) such that for any given Turing machine and finite initial tape T, then (x) can sometimes compute whether 's execution on tape T will eventually halt? Before we call this the x-machine halting problem, the phrase can sometimes compute whether must be defined so that this problem is well-posed. A reasonable definition requires some work.

From the universal Turing machine/enumeration theorem [21], there exists a Turing computable enumeration ε:→{all Turing machines }×{Each of 's states as an initial state} of every Turing machine. Similar to x-machines, for each machine , the set {Each of 's states as an initial state} can be realized as a finite subset {0, . . . , n−1} of . Since ε(n) is an ordered pair, the phrase “Turing machine ε(n)” refers to the first coordinate of ε(n). Similarly, the “initial state ε(n)” refers to the second coordinate of ε(n).

Recall that the Turing machine halting problem is equivalent to the blank-tape halting problem. (See pages 150-151 of [15]). For our discussion, the blank-tape halting problem translates to: for each Turing machine ε(n), does Turing machine ε(n) halt when ε(n) begins its execution with a blank initial tape and initial state ε(n)?

Lemma 7.1 implies that the same initial x-machine can evolve to two different x-machines; furthermore, these two x-machines will never compute the same language no matter what descendants they evolve to. For example, (0 x) and (1 x) can never compute the same language in . Hence, sometimes means that for each n, there exists an evolution of (x) to (a₀x), and then to (a₀a₁x) and so on up to (a₀a₁ . . . a_n x), where for each i with 0≤i≤n, then (a₀a₁ . . . a_n x) correctly computes whether Turing machine ε(n)−executing on an initial blank tape with initial state ε(n)−halts or does not halt.

In the prior sentence, the word computes means that (a₀a₁ . . . a_i x) halts after a finite number of instructions have been executed and the halting output written by (a₀a₁ . . . a_i x) on its tape indicates whether machine ε(n) halts or does not halt. For example, if the input tape is # #aⁱ#, then enumeration machine _E writes the representation of ε(i) on the tape, and then (a₀a₁ . . . a_m x) with m≥i halts with #Y# written to the right of the representation for machine ε(i). Alternatively (a₀a₁ . . . a_m x) with m≥i halts with #N# written to the right of the representation for machine ε(i). The word correctly means that x-machine (a₀a_i . . . a_m x) halts with #Y# written on the tape if machine ε(i) halts and x-machine (a₀a₁ . . . x) halts with #N# written on the tape if machine ε(i) does not halt.

Next, our goal is to transform the x-machine halting problem to a form so that the results from the previous section can be applied. Choose the alphabet as ={#, 0, 1, a, A, B, M, N, S, X, Y}. As before, for each Turing machine, it is helpful to identify the set of machine states Q as a finite subset of . Let _E be the Turing machine that computes a Turing computable enumeration as ε_a:→{}*×, where the tape # #aⁿ# represents natural number n. Each ε_a(n) is an ordered pair where the first coordinate is the Turing machine and the second coordinate is an initial state chosen from one of ε_a(n)'s states. (Chapter 7 of [15] provides explicit details of encoding quintuples with a particular universal Turing machine. Alphabet was selected so that it is compatible with this encoding. A careful study of chapter 7 provides a clear path of how _E's instructions can be specified to implement ε_a.)

Remark 8.1

For each n∈, with blank initial tape and initial state ε_a(n), then Turing machine ε_a(n) either halts or does not halt.

Proof. The execution behavior of Turing machine computation is unambiguous. For each n, there are only two possibilities.

For our particular instance of ε_a, define the halting function h_εa:→{0, 1} as follows. For each n, set h_εa(n)=1, whenever Turing machine ε_a(n) with blank initial tape and initial state ε_a(n) halts. Otherwise, set h_εa(n)=0, if Turing machine ε_a(n) with blank initial tape and initial state ε_a(n) does not halt. Remark 8.1 implies that function h_εa(n) is well-defined. Via the halting function h_εa (n) and definition 7.1, define the halting language

$L_{h_{{\epsilon }_a}}.$

Theorem 8.1

The x-machine (x) has an evolutionary path that computes halting language

$L_{h_{{\epsilon }_a}}.$ This evolutionary path is (h_εa(0) x)→(h_εa(0) h_εa(1) x)→ . . . (h_εa(0) h_εa(1) . . . h_εa(m) x) . . .Proof. Theorem 8.1 follows from the previous discussion, including the definition of halting function h_εa(n) and halting language

$L_{h_{{\epsilon }_a}}$ and theorem 7.2.

8.1 Some Observations Based on Theorem 8.1

Theorem 8.1 provides an affirmative answer to the x-machine halting problem, but in practice, a particular execution of (x) will not, from a probabilistic perspective, evolve to compute L_h(ε_a). For example, the probability is 2⁻¹²⁸ that a particular execution of (x) will evolve to (a₀a₁ . . . a₁₂₇ x) so that (a₀a₁ . . . a₉₉ x) correctly computes whether each string λ, a, a² . . . a¹²⁷ is a member of L_h(εa) or not a member of L_h(εa).

Furthermore, theorem 8.1 provides no general method for infallibly testing (proving) that an evolution of (x) to some new machine (a₀a₁ . . . a_m x) satisfies a_i=h_εa(i) for each 0≤i≤m. We also know that any such general testing method that works for all natural numbers m would need at least an ex-machine because any general testing method cannot be implemented with a standard machine. Otherwise, if such a testing method could be executed by a standard machine, then this testing machine could be used to solve Turing's halting problem; this is logically impossible due to Turing's proof of the unsolvability of the halting problem with a standard machine (digital computer). This unsolvability has practical ramifications for program correctness in software, and circuit verification in hardware.

The existence of the path shows that it is logically possible for this evolution to happen, since (x) can in principle evolve to compute any language L_f in . In other words, every infinite, downward path in the infinite binary tree of FIG. 3 is possible and equally likely. This section also mathematically demonstrates the computational limitations of the prior art, which is a digital computer.

In a sense, theorem 8.1 has an analogous result in pure mathematics. The Brouwer fixed point theorem guarantees that a continuous map from an n-simplex to an n-simplex has at least one fixed point and demonstrates the power of algebraic topology. However, the early proofs were indirect and provided no constructive methods for finding the fixed point(s). The parallel here is that theorem 8.1 guarantees that an evolutionary path exists, but the proof provides no general method for infallibly testing that for an evolution up to stage m, then (a₀a_l . . . a_m x) satisfies a_i=h_εa (i) for each 0≤i≤m. This is why the self-modification methods integrated with randomness are used.

9 The ϕ Correspondence

In the previous section, entitled “The Ex-Machine Halting Problem”, the ex-machine is not limited by the halting problem due to its meta instructions and random instructions that use self-modification and randomness. This capability of the ex-machine has some extremely practical applications. In the prior art, program correctness of standard program is unsolvable by a standard machine or digital computer, as a consequence of Turing's halting problem. Program correctness is extremely important not only due to the problem of malware [28] infecting mission critical software. However, program correctness is also critical to any hardware/software system —regardless of whether it is infected with malware—that operates air traffic control, the electric grid, the Internet, GPS [16], an autonomous driving network, and so on.

This section shows how to convert any standard program to a geometric problem; then novel self-modification procedures and/or traditional machine learning methods, implemented with the ex-machine's self-modification capability, can be used to solve the geometric problem. For example, the detection of an infinite loop in a standard program is a special case of the halting problem, and the detection of infinite loops is a subset of program correctness.

With this in mind, the ϕ correspondence can translate any standard digital computer program—no matter how big—to a geometric problem in the complex plane . Consider standard machine M. A transformation ϕ is defined such that each standard instruction in M is mapped to an affine function in the complex plane . Let machine states Q={q₁, . . . , q_m}. Let alphabet A={a₁, . . . , a_n}, where a₁ is the blank symbol #. Halt state h is not in Q. Function η: Q×A→Q∪{h}×A×{−1,+1} represents the standard machine instructions, where n(q, a)=(r, b, x) corresponds to standard instruction (q, a, r, b, x). Set B=|A|+|Q|+1. Define symbol value function v: A ∪{h}∪Q→ as v(a₁)=0, v(a₂)=1, . . . , v(a_i)=i−1, v(h)=|A|, v(q₁)=|A|+1, . . . , v(q_i)=|A|+i.

T_k is the memory value in the kth memory address. The machine configuration (q, k, T) lies in Q××A^Z. Machine configuration (q, k, T) is mapped to the complex number

$\varphi \left(q,k,T\right)=\sum _{j=-1}^{\infty }v\left(T_{k+j+1}\right){❘A❘}^{-j}+\left(\mathrm{Bv}\left(q\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){❘A❘}^{-j}\right)i.$ The real and imaginary parts of ϕ(q, k, T) are rational because the finitely bounded memory condition (i.e., finite memory) for standard machines implies that only a finite number of memory cells contain non-blank values.

Remark 9.1

If two machine configurations (q, l, T) and (r, k, S) are not equivalent, then ϕ(q, l, T)≠ϕ(r, k, S). That is, ϕ is one-to-one on the equivalence classes of machine configurations.

Proof. By translating our memory representation T via R(j)=T(j+l−k), W.L.O.G. we may assume that l=k. Thus, we are comparing (q, k, T) and (r, k, S). Suppose

$\sum _{j=-1}^{\infty }v\left(T_{k+j+1}\right){❘A❘}^{-j}+\left(\mathrm{Bv}\left(q\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){❘A❘}^{-j}\right)i=\sum _{j=-1}^{\infty }v\left(S_{k+j+1}\right){❘A❘}^{-j}+\left(Bv\left(r\right)+\sum _{j=0}^{\infty }v\left(S_{k-j-1}\right){❘A❘}^{-j}\right)i.$ Then the real parts must be equal. This implies for all j≥−1 that T_k+j+1=S_k+j+1. Hence, T_j=S_j for all j≥k.

For the imaginary parts, |Bv(q)−Bv(r)|≥B whenever q≠r. Also,

$0\le \sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){❘A❘}^{-j}<\frac{❘A❘-1}{1-\frac{1}{❘A❘}}=❘A❘.$ Similarly,

$0\le \sum _{j=0}^{\infty }v\left(S_{k-j-1}\right){❘A❘}^{-j}<❘A❘.$ Hence,

$❘\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){❘A❘}^{-j}-\sum _{j=0}^{\infty }v\left(S_{k-j-1}\right){❘A❘}^{-j}❘<❘A❘.$ Since B>|A|, this implies q=r and T_k−j−1=S_k−j−1 for all j≥0. This means T_j=S_j for all j≤k−1. Thus, (q, k, T)=(r, k, S).

This next part defines a one-to-one mapping ϕ from a standard digital computer program η to a finite set of affine functions, whose domain is a bounded subset of . From FIG. 7A, one can derive equation 1 for the real part of the machine configuration 710 and equation 2 for the imaginary part of the machine configuration 710.

$\begin{array}{cc}x=❘A❘v\left(T_k\right)+\sum _{j=0}^{\infty }v\left(T_{k+j+1}\right){❘A❘}^{-j}& \left(1\right)\end{array}$ $\begin{array}{cc}y=\mathrm{Bv}\left(q\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){❘A❘}^{-j}& \left(2\right)\end{array}$

Right Affine Map

Before executing instruction (q, T_k, r, b, +1), the machine is in configuration 710 as shown in FIG. 7A. During this computational step (execution step), machine state q moves to state r. Memory value b replaces T_k at memory address k, and the memory head moves to memory address k+1. The corresponding right affine function is of the form f(x+yi)=f₁(x)+f₂(y) i, where

$f_1\left(x\right)=❘A❘x+m\mathrm{and}{f}_2\left(y\right)=\frac{1}{❘A❘}y+n.$ FIG. 7B machine configuration 725 after instruction 720 (q, T_k, r, b, +1) executes. Machine configuration 725 is used to compute the value of m in f₁(x) and n in f₂(x).

$f_1\left(x\right)=❘A❘v\left(T_{k+1}\right)+\sum _{j=1}^{\infty }v\left(T_{k+j+1}\right){❘A❘}^{-j+1}.$ From equation 1,

$❘A❘x={❘A❘}^{2}v\left(T_k\right)+\sum _{j=0}^{\infty }v\left(T_{k+j+1}\right){❘A❘}^{-j+1}.$ Hence,

$m=f_1\left(x\right)-❘A❘x=❘A❘v\left(T_{k+1}\right)-{❘A❘}^{2}v\left(T_k\right)+\sum _{j=1}^{\infty }v\left(T_{k+j+1}\right){❘A❘}^{-j+1}-\sum _{j=0}^{\infty }v\left(T_{k+j+1}\right){❘A❘}^{-j+1}=❘A❘v\left(T_{k+1}\right)-{❘A❘}^{2}v\left(T_k\right)-v\left(T_{k+1}\right).$ Equation 3 defines the real part of the affine map for instruction (q, T_k, r, b, +1).f₁(x)=|A|x+(|A|−1)v(T_k+1)−|A|²v(T_k)  (3)

$f_2\left(y\right)=\mathrm{Bv}\left(r\right)+v\left(b\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){❘A❘}^{-j-1}.$ From equation 2,

$\frac{1}{A}y=\frac{B}{A}v\left(q\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){A}^{-j-1}.$ Hence,

$n=f_2\left(y\right)-\frac{1}{A}y=Bv\left(r\right)+v\left(b\right)-\frac{B}{A}v\left(q\right).$ Equation 4 defines the imaginary part of right affine map corresponding to instruction 720, where (q, T_k, r, b, +1) is shown in FIG. 7B.

$\begin{array}{cc}{f}_2\left(y\right)=\frac{1}{A}y+Bv\left(r\right)+v\left(b\right)-\frac{B}{A}v\left(q\right)& \left(4\right)\end{array}$

Left Affine Map

We compute the formula for ϕ mapping instruction (q, T_k, r, b, −1) to left affine function g(x+yi)=g₁(x)+g₂(y) i, where

$g_1\left(x\right)=\frac{1}{A}x+m,\mathrm{and}{g}_2\left(y\right)=Ay+n.$ FIG. 7C shows machine configuration 735 after instruction 730 (q, T_k, r, b, −1) executes. Machine configuration 735 is used to compute m in g₁(x) and n in g₂(y).

First,

$g_1\left(x\right)=Av\left(T_{k-1}\right)+v\left(b\right)+\sum _{j=1}^{\infty }v\left(T_{k+j}\right){A}^{-j}.$ Before (q, T_k, r, b, −1) executes, equation 1 holds. Also,

$\frac{1}{A}x=v\left(T_k\right)+\sum _{j=1}^{\infty }v\left(T_{k+j}\right){A}^{-j}.$ Hence,

$m=g_1\left(x\right)-\frac{1}{A}x=Av\left(T_{k-1}\right)+v\left(b\right)-v\left(T_k\right).$

$\begin{array}{cc}{g}_1\left(x\right)=\frac{1}{A}x+Av\left(T_{k-1}\right)+v\left(b\right)-v\left(T_k\right)& \left(5\right)\end{array}$

For the imaginary part,

$g_2\left(y\right)=Bv\left(r\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-2}\right){A}^{-j}.$ Before instruction (q, T_k, r, b, −1) executes, equation 2 holds. Multiplying by |A| yields

$Ay=ABv\left(q\right)+Av\left(T_{k-1}\right)+\sum _{j=1}^{\infty }v\left(T_{k-j-1}\right){A}^{-j+1}.$ Lastly,

$n=g_2\left(y\right)-Ay=Bv\left(r\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-2}\right){A}^{-j}-ABv\left(q\right)-Av\left(T_{k-1}\right)-\sum _{j=1}^{\infty }v\left(T_{k-j-1}\right){A}^{-j+1}.$ Hence, n=Bv(r)−|A|Bv(q)−|A|v(T_k−1).g₂(y)=|A|y+Bv(r)−|A|Bv(q)−|A|v(T_k−1)  (6)

Define halting attractor _h={x+yi∈: 0≤x≤|A|²} and B|A|≤y≤(B+1)|A|}. The set of all points in that correspond to halting configurations (h, k, T) are called halting points. Remarks 9.2 and 9.3 establish that the halting points are a subset of _h. Define the halting map :_h→_h such that h(x+yi)=x+yi on _h. This means every point in the halting attractor is a fixed point.

Remark 9.2

Every halting point x_h+y_hi in _h satisfies B|A|≤y≤(B+1)|A|.

PROOF. Let x_h+y_hi be a halting point. Then

$y_h=Bv\left(h\right)+\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){A}^{-j}=BA+\sum _{j=0}^{\infty }v\left(T_{k-j-1}\right){A}^{-j}.$ Thus, y_h≥B|A| since a tape of all blanks yields 0 for the infinite sum. If A={#}, then the halting behavior is trivial, so we assume |A|≥2 for this next part. If v(T_k−j−1)=|A|−1 for all j≥0, then the sum of this geometric series is

$\frac{A-1}{1-\frac{1}{A}}=A.$

Remark 9.3

Every halting point x_h+y_hi in _h satisfies 0≤x_h<|A|².

PROOF. |x|≥0 because every term is ≥0. Analyzing equation 1

$x<A\left(A-1\right)+\frac{A-1}{1-\frac{1}{A}}={A}^2.$

Each affine function's domain is a subset of a unique unit square {x+yi ∈: m≤x≤m+1 and n≤y≤n+1}, where m and n are integers. Hence, ϕ transforms Turing's halting problem to the following dynamical systems problem, which is a type of geometric problem. If machine configuration (q, k, T) halts after n computational steps, then the orbit of ϕ (q, k, T) exits one of the unit squares on the nth iteration and enters halting attractor _h. In other words, we say that the execution of computer program η with initial configuration (q, k, T) enters the halting attractor _h after a finite number of execution steps, where it is understood that computer program η has been mapped to a finite set of affine maps, and initial configuration (q, k, T) has been mapped to an initial point ϕ (q, k, T) in .

If machine configuration (r, j, S) is immortal (i.e., never halts), then the orbit of ϕ(r, j, S) remains in these finite number of unit squares forever and never enters the halting attractor _h. In other words, the execution of computer program η with initial configuration (q, k, T) never enters halting attractor _h.

For a particular standard machine, set X equal to the union of all the closed unit squares induced by ϕ along with halting attractor _h. Closed means the unit squares contain their boundary. Because there are a finite number of unit squares and _h is a compact set, there is a set D that is compact (i.e., closed and bounded) and path connected such that D contains the closed unit squares and halting attractor _h. Define F: D→ as a function extension of the finite number of right and left affine functions f and g, specified by equations 3, 4, 5, 6 and also an extension of halting function .

10 Program Correctness Based on Entering the Halting Attractor

One of the main inventions, provided in this section, is that the correctness of a computer program with an initial configuration can be computed based on whether the program's execution enters the program's halting attractor _h in the complex plane . In other words, a new computational approach, implemented in hardware and software, to a deep, theoretical mathematical problem has many practical software and hardware applications and inventions that currently are believed to be unsolvable by the prior art.

In an embodiment, ex-machine receives as input standard instructions 110 (FIG. 1A) of a standard machine M (also called a computer program or standard computer program), that are stored in input system 242 (FIG. 2B) of ex-machine . An ex-machine also receives as input the initial configuration of the standard computer program: the initial configuration is comprised of the initial machine state q and initial memory contents T of the computer program M.

Ex-machine executes machine instructions 100 with processor system 252 and computes the left affine maps and right affine maps of M according to equations 3, 4, 5, and 6. Then ex-machine stores the left and right affine maps of M (i.e., the computational results of equations 3, 4, 5, and 6) in memory system 246.

In an embodiment, the ex-machine receives standard instructions 110 (FIG. 1A) as input that are expressed in the C programming language [12]. In an embodiment, the input to is a list of standard instructions 110, expressed as C code. There are three tests provided to function FFMul (unsigned char a, unsigned char b). During the execution of the computer program, if one of the three tests has an error, then the program enters the function infinite_error_loop (unsigned char a, unsigned char b) and never exits the loop; in other words, if one of the three tests of function FFMul (unsigned char a, unsigned char b) fails, then the execution of the program never enters its halting attractor. If the execution of this computer program successfully verifies all 3 tests, then the execution of the program exits function main( ) and successfully enters the halting attractor.

#include <stdio.h>
unsigned char FFMul(unsigned char a, unsigned char b)
{
unsigned char aa = a, bb = b, r = 0, t;
while (aa != 0)
{
if (aa & 1) != 0) r = (unsigned char) ( r {circumflex over ( )} bb);
t = (unsigned char) (bb & 0x80);
bb = (unsigned char) (bb << 1);
if (t != 0) bb = (unsigned char) (bb {circumflex over ( )} 0x1b);
aa = (unsigned char) ((aa & 0xff) >> 1);
}
return r;
}
void infinite_error_loop(unsigned char a, unsigned char b)
{
while(1)
{
printf(″PROGRAM ERROR with test a = %d and
b = %d \n″, a, b);
}
}
#define NUM_TESTS 3
int main( )
{
int i;
unsigned char test_result = 0;
unsigned char a[NUM_TESTS] = {59, 117, 197};
unsigned char b[NUM_TESTS] = {237, 88, 84};
unsigned char correct_result[NUM_TESTS] = {243, 208, 17};
for(i = 0; i < NUM_TESTS; i++)
{
test_result = FFMul(a[i], b[i]);
printf (″test_result = %d \n″, test_result);
if (test_result != correct_result[i])
{
infinite_error_loop(a[i], b[i]);
}
}
return 0;
}

In the prior C listing, the following comprise the initial configuration of this C program: the initial value of constant NUM_TESTS is set to 3; the initial value of the array variable a [NUM_TESTS] is set to 59, 117, and 197 in memory system 246; the initial value of the variable b [NUM_TESTS] is set to 237, 88, 84 in memory system 246; the initial value of the variable correct_result [NUM_TESTS] is set to 243, 208, 17 in memory system 246; the initial value of the variable test_result is set to 0 in memory system 246.

In an embodiment, the ex-machine receives as input standard instructions 110 (FIG. 1A) that are expressed in the programming language Python. For example, the input to could be the following list of standard instructions, expressed as Python code.

def sum_a_b_c(a, b, c):
return a + b + c
def sum_of_squares(a, b, c):
return (a * a) + (b * b) + (c * c)
def gcd(a, b):
while b:
temp = a
a = b
b = temp % b
# a, b = b, a % b
return a
def gcd_many(*numbers):
return reduce(gcd, numbers)
def abn_sum_of_squares(a, b, n):
return sum_of_squares(a, b, a * n + b )
def a_plus_b_plus_an_plus_b(a, b, n):
return n * (a + 1) + b + 1
def abn_compute_m(a, b, n):
abn_rem = abn_sum_of_squares(a, b, n) % a_plus_b_plus_an_plus_b(a, b, n)
if (0 == abn_rem) :
print_abc_solution(a, b, a * n + b)
m = abn_sum_of_squares(a, b, n) / a_plus_b_plus_an_plus_b(a, b, n)
print ″ m = ″, m
if (abn_rem > 0) :
# print ″\n remainder = ″, abn_rem
m = 0
return m
def isa_abc(a, b, c):
if (0 == sum_of_squares(a, b, c) % sum_a_b_c(a, b, c)) and ( gcd( gcd(a, b), c) < 2) :
return 1
else :
return 0
def print_abc_solution(a, b, c) :
print ″a = ″, a, ″ b = ″, b, ″ c = ″, c, ″ is an abc triplet. ″
return 0
def search_abc_pair(a, b, c_min, c_max) :
for c in range(c_min, c_max):
if isa_abc(a, b, c):
print_abc_solution(a, b, c)
print ″\n″
def test_abc_fns( ):
print ″\n 2 + 3 + 4 = ″, sum_a_b_c(2, 3, 4)
print ″\n 3{circumflex over ( )}2 + 4{circumflex over ( )}2 + 12{circumflex over ( )}2 = ″, sum_of_squares(3, 4, 12)
print ″\n gcd(35, 60) = ″, gcd(35, 60)
print ″\n gcd(2, 3) = ″, gcd(2, 3)
print ″\n gcd_many(35, 14, 21) = ″, gcd_many(35, 14, 21)
print ″\n″
return 0
a = 2
b = 5
for n in range(4, 500000):
abn_compute_m(a, b, n)
test_abc_fns( )
a = 2
b = 3
c = 14
if isa_abc(a, b, c):
print ″a = ″, a, ″ b = ″, b, ″ c = ″, c, ″ is an abc triplet\n″
else:
print ″a = ″, a, ″ b = ″, b, ″ c = ″, c, ″ is NOT an abc triplet.\n″

In another embodiment, the ex-machine receives as input standard instructions 110 (FIG. 1A) that are expressed in VHDL [25], a hardware dataflow language.

Machine Embodiment 4

Correctness of the Goldbach Conjecture

The purpose of the following program is to prove that the Goldbach conjecture is true. The Goldbach conjecture states that every even number greater than or equal to 4 is the sum of two primes. For example, 4=2+2, 6=3+3, 8=3+5, 10=3+7, 12=5+7, 14=3+11 and so on. The following code, named Goldbach Machine, is a correct program if its execution never reaches the halting attractor; that is, if its execution stays in the while (g==true) loop forever and never reaches the halt instruction. The code in the Goldbach machine can be transformed to a finite set of affine maps in the complex plane as described previously.

set n = 2
set g = true
set prime_list = (2)
while (g == true)
{
set n = n + 2
set g = false
for each p in prime_list
{
set x = n − p
if (x is a member of prime_list) set g = true
}
if (n−1 is prime) store n−1 in prime_list
}
print (″Even number ″ n ″ is not the sum of two primes.″)
print (″The Goldbach conjecture is false!″)
halt

Machine Embodiment 5

Correctness of a Hardware Circuit Design

We describe another embodiment of a program that can be checked for correctness. In hardware design, there are a finite number of timing constraints that determine if race conditions exist for a hardware circuit. Race conditions are usually considered to be a program error or hardware design error. In some cases, a computer program can be specified that checks each of these timing constraints; if one of the timing constraints is violated then the computer program can enter a trivial infinite loop such as

while(true)
{
print (″TIMING CONSTRAINT ERROR in hardware design circuit!″)
}

If none of the timing constraints are violated then the program enters a halting state, indicating that the computer program testing the timing constraints is correct. In this case, the entry of the computer program into the halting attractor indicates that the computer program is correct, and thus that there are no race conditions in the circuit design. In this case, in contrast to the Goldbach machine, the meaning of the computer program's execution entering the halting attractor is inverted from the program is incorrect to the program is correct.

Machine embodiment 4 and machine embodiment 5 teach us the following: for some computer programs, entering the halting attractor means that the program has an error; for other computer programs, entering the halting attractor means the program is correct. The meaning of a computer program entering the halting attractor depends upon the particular computer program and must be understood on a case by case basis.

10 Machine Learning with Self-modification and Randomness

In this section, we describe the inventions of using self-modification and randomness to advance machine learning procedures. In the prior art, machine learning procedures are implemented with algorithms that are computationally equivalent to a Turing machine algorithm [5, 14, 15, 24]. As was shown in sections 7 and 8, machine computation that adds randomness and self-modification to the standard digital computer instructions has more computing capability than a standard digital computer. This capability enables more advanced machine learning procedures where in some embodiments meta instructions 120 and random instructions 140 improve the machine learning procedure.

In the prior art, some machine learning algorithms use multi-layer methods of building functions, based on the use of weighted sums of sigmoidal functions (FIG. 8A) or some other nonlinear function that are fed into the next layer. For example, see FIG. 8C, where each node has a sigmoidal function. In our embodiments,

$g\left(x\right)=\frac{2}{\pi }\arctan \left(x\right)$ is our prototypical sigmoidal function 810, as shown in FIG. 8A. First, it is important to observe that the prior art—not understanding that computation is capable of computing Turing incomputable languages—only uses a Turing machine algorithm for its machine learning methods. This may be at least part of the reason why machine learning algorithms work well up to a certain amount of training and then suddenly hits a wall in terms of the tasks that a machine learning algorithm can perform.

When the nonlinear functions are sigmoidal functions 810, we will call this a neural network, as shown in FIG. 8C. In the prior art, the learning algorithm for multi-layer methods is a type of gradient descent: the weights in each weighted sum of the neural network are adjusted according to an error function that is computed according to how well the neural network is able to classify or predict examples on the training data set. The gradient descent is computed with respect to the error function computed on the training data set, where the gradient descent adjusts the weights to reduce the error in the direction of the gradient. In the prior art, the gradient descent methods such as backpropagation [11] are Turing machine algorithms.

In our embodiments, our almost step functions will generally be piecewise linear approximations of the form g_a,b,c(x)=exp (−b(x−a)^c), where b and c are parameters that adjust the width of where the step function maps that interval to 1 and a translates the center of the step function. In FIG. 8B, the center of the almost step function is located at x=0 and b=2 and c=20. If we choose c=b², then we can form 10 different almost step functions with b values in { 1/100, 1/10, 2, 4, 10, 100, 1000, 10⁴} so that rare events can be localized or almost all events of a certain type are ignored. For embodiments with more flexibility with b and c independent of each other, we can choose a, b and c vary randomly, executed with random instructions. The derivative of a piecewise linear approximation of g_a,b,c(x)=exp (−b(x−a)^c) exists everywhere when we take the average of the slopes at the vertices of the approximation. We start with almost step functions because of the following theorem from real analysis. For any Lebesgue measurable function f:[0,1]→ and for any ϵ>0, there exists a finite sum of step functions

$\sum _{j=1}^n{\chi }_j\left(x\right)$ such that

$\sum _{j=1}^n{\chi }_j\left(x\right)-f\left(x\right)<ϵ$ on a set of Lebesgue measure greater than 1−∈.

In some embodiments, our machine learning procedure, comprised of standard, random and meta instructions, starts with a gradient descent methods that can be used on networks of almost step and sigmoidal functions. The meta instructions can be used to modify our initial gradient descent procedure and also modify how the gradient descent is understanding the differential geometry of our network of nonlinear functions. In some embodiments, the self-modification of the initial gradient descent will depend upon differential forms, curvature tensors, and the curvature of saddle points so that standard instructions 940, meta instructions 930 and random instructions 920 can reason about the performance of machine learning procedure 950 that is evolving, based on its training data set. Meta instructions 930 and random instructions 920 help self-modify machine learning procedure, based on the reasoning that depends upon the geometric concepts of differential forms, curvature tensors, and the curvature of saddle points. How the machine learning procedure evolves will sometimes depend upon the idiosyncracies of a particular data set where the training is performed upon.

In some embodiments, we use almost step functions 820, shown in our FIG. 8B, that are a piecewise linear approximation of g_a,b,c(x)=exp (−b(x−a)^c). In some embodiments, we use almost step functions 820 and sigmoidal functions 810 in our machine learning procedure, or a compositional function at node, that is composed of weighted sum of almost step functions and sigmoidal functions. In an embodiment, the building of arbitrary compositional functions executes standard instructions 110, random instructions, and meta instructions so there is no algorithmic constraint on how these compositional functions are constructed. In embodiments, we call this a network of nonlinear functions 850, so that our non-algorithmic method of building function composition is distinguished from the prior art that uses neural networks 830 containing only sigmoidal functions or a network of one type of nonlinear function.

In some embodiments, two subscripts indicate the layer and reference the particular nonlinear function 850 at that location. In an embodiment, there are n different nonlinear functions that we use at each node of the network and they are named ={f₁(x), f₂(x), . . . f_n(x)}. In FIG. 8C, n=1, where

$f_1\left(x\right)=\frac{2}{\pi }\arctan \left(x\right).$ In FIG. 8D, n=2, where

$f_1\left(x\right)=g\left(x\right)=\frac{2}{\pi }$ arctan (x) and

$f_2\left(x\right)=\chi \left(x\right)=e^{-{\left(\mathrm{cx}\right)}^{c^2}}.$

The use of multi-layer algorithmic machine learning is based on weighted sigmoidal functions 810, or some other non-linear function that looks like a hockey stick constructed from two linear pieces.

In a machine learning procedure 950 embodiment that uses standard instructions 940, random instructions 920 and meta instructions 930, as shown in FIG. 8E, Each function g_i,j(x) 850 is selected from and is located at a node, that is in the jth column of layer i. Let n_i be the number of nodes in layer i. In an embodiment, a weighted linear sum from layer i to nonlinear function g_+1,l(x) in the next layer i+1 is

$\sum _{j=1}^{n_i}$ w_i,j,lg_i+1,j, as shown in FIG. 8E.

12 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 12.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 5 is easier to analyze and implement. Some embodiments of procedure 5 can be implemented using randomness generator 548 in FIG. 5A. In some embodiments, the randomness generator 542 in FIG. 5A along with a source of photons shown in FIG. 6A, FIG. 6B, and FIG. 6C can help implement procedure 5 with random measurements 130, shown in FIG. 130. 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 random measurements 130 in FIG. 1A helps select the next instruction to execute. In some embodiments, the quantum randomness is measured, using the non-deterministic hardware shown in 5A or 5B. In another embodiment, quantum randomness is measured, using the non-deterministic hardware shown in 5C, where the spin-1 source of non-determinism is obtained by measuring the spin of electrons.

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 130 in FIG. 1A 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. 5C.

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 \mathbb{Q}\mathrm{and}\frac{1+\sqrt{5}}{2}\notin \mathbb{Q}.$ The symbol ∩ means intersection. Note

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

Machine Specification 12.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 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 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₂, . . . , } is a finite set of rational numbers, contained in 109 [0,1], such that = where is the number of instructions in .
  • v:→ is a bijective function. Let I be an instruction in . The purpose of v(I) is to help derive the likelihood of non-deterministically selecting instruction I as the next instruction to execute.

Non-deterministic machine 12.1 can be used to execute two different instances of a procedure with a different sequence of machine instructions 100, as shown in FIG. 1A.

Machine Specification 12.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 12.1, then

${ℳ}_i\stackrel{I}{\mapsto }{ℳ}_{i+1}$ 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. v(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 \mathbb{Q}\mathrm{and}\frac{1+\sqrt{5}}{2}\notin \mathbb{Q}.$ The symbol ∩ means intersection. Note

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

The purpose of machine procedure 4 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 4 can be implemented as a computing system (FIG. 2B) with input system 242, output system 240, memory system 246, random system 248, self-modifiable system 250 and processor system 252 with standard instructions 110, meta instructions 120, and random instructions 6740, as shown in FIG. 1A. Combining procedure 4 and recognizing that the other parts of machine specification 12.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 12.1.

Machine Specification 4

; ; 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 + δ
}
set                      ⁢                                                                                          ⁢                      δ                                        =                                                                  1                        2                                            ⁢                                                                                          ⁢                      min                      ⁢                                              {                                                                              δ                            1                                                    ,                                                      δ                            2                                                    ,                          …                          ⁢                                                                                                          ,                                                      δ                            m                                                                          }
comput 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) 5 can be implemented with standard instructions 110, meta instructions 120, and random instructions 140, as shown in FIG. 1A. Random instructions 140 take random measurements 130, while executing. In some embodiments, quantum random measurements 130 are measured with spin-1 source (e.g., electrons), followed by a S_z splitter and an S_x splitter as shown in FIG. 5C. In other embodiments, random measurements 130 are measured with a randomness generator 552, as shown in FIG. 5B. In some embodiments, the source of the quantum events is photons, as shown in FIG. 6A, FIG. 6B, and FIG. 6C.

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 the 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. */
}

or function such as

In another embodiment, the instructions non-deterministically selected can be performed at the hardware level, using the VHDL dataflow language.

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, or a hardware language such as VHDL.

Machine Specification 5

; ; | | 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 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 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 4
Per definition 12.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) 5, 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 Specification 6

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 × A × Q × A × {−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 Jq,a by executing procedure 4.
Per specification 12.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 a final state fi
{
if d > dmax set dmax = d
}
increment j
}
increment l
}
OUTPUT: dmax

Machine specification 6 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 specification 6 can be executed with a finite sequence of standard, meta and random instructions as shown in FIG. 1A.

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

Machine Computation Property 12.1

For each x, let v_x=v(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_f and p=v_j1*v_j2* . . . *v_jN is a maximum. The expected number of times that inner loop in procedure 6 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=v_j1*v_j2* . . . *v_jN. When n>N, the probability of executing this path is still p because the inner loop exits if the final state in _N is reached.

REFERENCES

• [1] John Bell. On the Einstein Podolsky Rosen Paradox. Physics. 1, 1964, pp. 195-200.
• [2] Neil Bohr. Can Quantum-Mechanical Description of Physical Reality be Considered Complete? Physical Review. 48, Oct. 15, 1935, pp. 696-702
• [3] Louis de Broglie. Recherches sur la th eorie des quanta. Ph.D. Thesis. Paris, 1924.
• [4] A. A. Abbott, C. S. Calude, J. Conder, and K. Svozil. Strong Kochen-Specker theorem and incomputability quantum randomness. Phys. Rev. A 86, 062109, 2012, pp. 1-11
• [5] Martin Davis. Computability and Unsolvability. Dover Publications, New York, 1982.
• [6] David Deutsch. Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer. Proc. London Math. Soc. Series A. 400, No. 1818, 1985, pp. 97-117.
• [7] Antony Eagle. Randomness Is Unpredictability. British Journal of Philosophy of Science. 56, 2005, pp. 749-790.
• [8] Albert Einstein, Boris Podolsky and Nathan Rosen. Can Quantum-Mechanical Description of Physical Reality Be Considered Complete? Physical Review. 47, 1935, pp. 777-780.
• [9] William Feller. An Introduction to Probability Theory and Its Applications, Volume 1, Third Edition. John Wiley & Sons, New York, 1968, pp. 202-211.
• [10] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP-Completeness. W.H. Freeman, 1979.
• [11] John Hertz, Anders Krogh and Richard G. Palmer. Introduction To The Theory of Neural Computation. Addison-Wesley Publishing Company. Redwood City, Calif., 1991, pp. 115-121.
• [12] Brian Kernighan and Dennis Ritchie. The C Programming Language. 2nd Edition, Prentice Hall, 1988.
• [13] Simon Kochen and E. P. Specker. The Problem of Hidden Variables in Quantum Mechanics. Journal of Mathematics and Mechanics. Vol. 17, No. 1, 1967, pp. 5987.
• [14] Harry R. Lewis and Christos H. Papadimitriou. Elements Of The Theory Of Computation. Prentice-Hall, 1981.
• [15] Marvin Minsky. Computation: Finite and Infinite Machines (1st edition). Englewood Cliffs, N.J. Prentice-Hall, Inc, 1967.
• [16] Pratap Misra and Per Enge. Global Positioning System: Signals, Measurements, and Performance. Revised 2nd Edition, Ganga-Jamuna Press, 2011.
• [17] David A. Patterson and John L. Hennessy. Computer Architecture: A Quantitative Approach. 5th Edition, Morgan Kaufmann, 2011.
• [18] H. L. Royden. Real Analysis. Prentice-Hall Inc., 1988.
• [19] Alfred A. Schmitt. The State Complexity of Turing Machines. Information and Control. 17, 1970, pp. 217-225.
• [20] Claude Shannon. Communication Theory of Secrecy Systems. netlab.cs.edu/wiki/files/shannon1949.pdf. 1949.
• [21] Hartley Rogers, Jr. Theory of Recursive Functions and Effective Computability. MIT Press, 1987.
• [22] Andre Stefanov, Nicolas Gisin, Olivier Guinnard, Laurent Guinnard and Hugo Zbinden. Optical quantum random number generator. Journal of Modern Optics. 1362-3044, 47, 4, 2000, pp. 595598. http://arxiv.org/pdf/quantph/9907006
• [23] H. E. Sturgis, and J. C. Shepherdson. Computability of Recursive Functions. J. Assoc. Comput. Mach. 10, 1963, pp. 217-255.
• [24] Alan M. Turing. On computable numbers, with an application to the Entscheidungsproblem. Proc. London Math. Soc. Series 2 42 (Parts 3 and 4), 230265 (1936). A correction, ibid. 43, 1937, pp. 544546.
• [25] VHSIC Hardware Description Language. 2019. https://en.m.wikipedia.org/wiki/VHDL
• [26] M. Wahl, M. Leifgen, M. Berlin, T. Rohlickel, Hans-Jurgen Rahn, and O. Benson. An ultrafast quantum random number generator with provably bounded output bias based on photon arrival time measurements. Applied Physics Letters. 98, 171105, 2011.
• [27] 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.
• [28] D. Zamboni (editor). Proc. of the 5th Intl. Conf. on Detection of Intrusions and Malware LNCS. Springer. July 2008.

Claims

1. A machine-implemented method for verifying program correctness comprising: the machine having a processor system, memory system, and input system;the machine receiving a computer program and the program's initial configuration as input;the machine mapping the computer program to finite set of affine maps;the machine computing that the execution of the computer program with its initial configuration enters the program's halting attractor after a finite number of execution steps;wherein entering the halting attractor verifies the correctness of the computer program.

2. The method of claim 1 wherein the machine verifying the program correctness can be computed with a finite number of standard instructions, meta instructions and random instructions.

3. The method of claim 2 wherein the execution of a random instruction measures one or more quantum events.

4. A machine-implemented method for verifying program correctness comprising: the machine having a processor system, memory system, and input system;the machine receiving a computer program and the program's initial configuration as input;the machine mapping the computer program to a finite set of affine maps;the machine computing that the execution of the computer program with its initial configuration never enters the program's halting attractor;wherein never entering the halting attractor verifies the correctness of the computer program.

5. The method of claim 4 wherein the machine verifying the program correctness can be computed with a finite number of standard instructions, meta instructions and random instructions.

6. The method of claim 5 wherein the random instructions execute by performing random measurements of quantum events.