Quantum Random, Self-Modifiable Computer

Abstract

The present invention describes a computing machine, called an ex-machine, which uses self-modification and randomness to enhance computing power. In an embodiment, the ex-machine has three types of instructions: standard instructions, meta-instructions, and random instructions. In an embodiment, the meta-instructions self-modify the machine when executed, thereby adding new instructions. In an embodiment, the standard instructions are expressed in the C programming language or the VHDL dataflow language. The random instructions are randomly measured from a random source. In an embodiment, the random source generates quantum events to be measured. In an embodiment, the ex-machine combines its random instructions and its meta-instructions to self-modify the ex-machine instructions, such that it can evolve to compute (i.e., verify) the correctness of a computer program it receives as input. In an embodiment, when the ex-machine computes, the ex-machine uses its meta-instructions and random instructions to improve its machine learning program.

Description

[0001] Related Applications

[0002] This application claims priority to U.S. Provisional Patent Application No. 62 / 682,979, filed on Jun. 10, 2018, entitled "Quantum Random Self-Modifiable Computer". Technical Field

[0003] This specification generally relates to computing: computing hardware, random number generation in computing, random instructions, machine-implemented methods, machine-implemented systems, and self-modification of programs and hardware. Background Art

[0004] Consider two fundamental problems in computer science: these two fundamental problems largely influence the design of current digital computers and play a fundamental role in the hardware and machine-implemented software of the prior art:

[0005] 1. What can a computing machine compute?

[0006] 2. How many computational steps does a computing machine need to solve an instance of the 3-SAT problem? The 3-SAT problem is a well-known basis of the problem

[10] .

[0007] In the prior art, these two problems are generally conceived and implemented using hardware and software that compute according to the Turing machine (TM)

[24] (i.e., a standard digital computer

[17] ) model, which is the standard model of computing in the prior art [5, 6, 10, 15, 23]. Summary of the Invention

[0008] In the present invention, computing is advanced by applying new machine-implemented methods and new hardware - particularly machine learning and program correctness computation of standard digital computer programs - and our implementations far exceed the prior art. The machine implementations divide the first problem into two problems. What is computing? What can computing compute? Our new computer adds two special types of instructions to the instructions 110 of a standard digital computer

[17] , as Figure 1A shown. Some implementations are called ex-machines - derived from the Latin extra machinam - because ex-machine computations generate new dynamic behaviors and computational capabilities, and one may no longer consider them a standard digital computer or a typical machine.

[0009] One type of special machine instruction is Figure 1A the meta-instruction 120 inFigure 2B As shown. When the ex-machine executes a meta-instruction, the meta-instruction can add a new state, add a new instruction, or replace an instruction. Different from typical machines in the general sense (e.g., inclined plane, lever, pulley, wedge, wheel and axle, Archimedes screw, Galileo telescope, or bicycle), the meta-instruction increases the complexity of the ex-machine [19, 20].

[0010] Another special instruction is Figure 1A the random instruction 140 in, which can be physically implemented using a random measurement 130. In some embodiments, as Figure 5A , Figure 5B and Figure 5C shown, light-emitting diodes emit photons, which are detected by the random measurement 130. In other embodiments, the random instruction 140 can be implemented using non-determinism generated by physical processes such as atmospheric noise, sound, humidity, temperature measurement, pressure measurement, fluid turbulence, the number of storage head reads in a digital computer due to air turbulence or friction in the hardware storage head, or protein folding. Due to the random instruction 140, even if two ex-machines start their execution with the same input in memory, the same program instructions, the same initial machine state, etc., the execution behaviors of these two ex-machines may be different. Even when started with the same initial conditions, two identical ex-machines that are distinct from each other may exhibit different execution behaviors. When this property of the random instruction is combined with the appropriate use of the meta-instruction 120, as the execution of each corresponding machine proceeds, two identical machines with the same initial conditions can develop into two different computations: this unpredictable behavior is very useful in machine learning applications and cryptographic computations. This property makes it more difficult for an adversary to attack or tamper with the computation. This property enables the ex-machine program to develop new machine learning programs.

[0011] Some of the computations provided here by ex-machine programs transcend the Turing barrier (i.e., exceed the computational capabilities of digital computers). Computations that transcend this barrier have advantages over the prior art, especially for machine learning applications, cryptographic computations, and the implementation of verifying program correctness in standard digital computer programs. Additionally, these implementations provide machine programs for computing languages that cannot be computed by register machines, standard digital computers, or Turing machines. In the disclosures of these inventions, a countable set of ex-machines is explicitly specified using standard instructions, meta-instructions, and random instructions. Using probability mathematics, measure theory, and Cantor's infinite hierarchy, we prove that as long as the random measurement 130 (trials) behaves like an unbiased Bernoulli trial, each of these ex-machines can evolve with probability measure 1 to compute languages that cannot be computed by digital computers. (Turing machines

[24] or digital computers

[17] cannot compute non-computable Turing languages.) For this reason, when we discuss computational methods in the prior art, we refer to Turing machine programs or digital computer programs as algorithms. Since the mechanical rules of an algorithm are fixed throughout the computation and the complexity of an algorithm remains constant during all executions of the algorithm, we never refer to ex-machine computations as algorithms. Overall, the mathematics presented in this paper shows that ex-machine inventions far exceed the prior art. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] In the following drawings, although these drawings may depict various embodiments of the present invention, the present invention is not limited to the embodiments depicted in the drawings.

[0013] Figure 1A An embodiment of an ex-machine is shown, which includes machine instructions 100 (including standard instructions 110, random instructions 140, and meta-instructions 120), a random measurement 130, a memory 116, a memory value 118, and a machine state 114.

[0014] Figure 1B An embodiment of a random instruction 150 is shown, which includes a randomness generator 160 that measures the randomness of one or more quantum events 170.

[0015] Figure 1C An embodiment of an executed meta-instruction 120 is shown ( Figure 1A ). In Figure 1C , upon execution, the meta-instruction (5,0,│Q│-1,1,0,J) creates a new standard instruction J = (7,1,8,#,-1).

[0016] Figure 1D An embodiment of a meta-instruction is shown, wherein the new standard instruction J = (7,1,8,#,-1) is executed immediately after it is created in Figure 1C .

[0017] Figure 2A Illustrates an implementation of a computer network implemented with an ex-machine. In some implementations, the transmission can be carried out over the Internet or a part of a network of a support infrastructure (such as a power grid, a financial exchange, or a power plant).

[0018] Figure 2B Illustrates an implementation of a computer architecture implementing an ex-machine, which includes a processor, a memory, and an input / output system, a random system, and a self-modifying system. This implementation can be Figure 1A of the ex-machine.

[0019] Figure 3 Illustrates a graphical representation of an infinite binary tree. This figure helps to intuitively illustrate why an ex-machine (such as etc.) can compute languages that a standard machine cannot compute.

[0020] Figure 4 Illustrates a mobile smartphone implementation 400 that computes and transmits wireless voice data, which may include Figure 1A machine instructions. The mobile phone 500 is an implementation of an ex-machine that intelligently sends security commands and keys to control a car.

[0021] Figure 5A Illustrates an implementation 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.

[0022] The randomness generator 542 measures randomness based on the behavior of photons. The randomness generator 542 includes a light-emitting diode 546 that emits photons and a phototransistor 544 that absorbs and detects photons.

[0023] Figure 5B Illustrates an implementation of a randomness generator based on quantum randomness. The randomness generator 552 makes random measurements based on the behavior of photons. The randomness generator 552 includes a light-emitting diode 556 that emits photons and a photodiode 554 that absorbs and detects photons.

[0024] Figure 5C Illustrates an implementation of a random measurement 130 that uses a quantum event 565 to provide a rotation - 1 source 560; followed by an S z beam splitter 570; then an S x beam splitter 580, which produces a random binary result. In an implementation, an electron serves as the rotation - 1 source.

[0025] Figure 6AA light-emitting diode is shown, which emits photons and is part of a random number generator in some embodiments. The light-emitting diode includes a cathode, a diode, an anode, a lead connected to the cathode, a lead connected to the anode, a p-layer of semiconductor, an active region, an n-layer of semiconductor, a substrate, and a transparent plastic case.

[0026] Figure 6B A light-emitting diode including a semiconductor chip is shown.

[0027] Figure 6C A light-emitting diode is shown, a semiconductor view of the light-emitting diode is shown, and it includes electron and hole currents based on the conduction band and valence band.

[0028] Figure 7A A standard machine configuration in machine state q before executing standard machine instructions is shown, and the contents of its memory are shown in sequential representation. The purpose is to understand how to convert instructions into geometric mappings.

[0029] Figure 7B A standard machine configuration in machine state r after executing standard machine instructions is shown, and the contents of its memory are shown in sequential representation.

[0030] Figure 7C A standard machine configuration in machine state r after executing standard machine instructions is shown, and the contents of its memory are shown in sequential representation.

[0031] Figure 7D A right affine mapping 740 is shown, which is a function of two variables x, y and a stop attractor 750. The explicit calculation represented as two functions f 1 (x,y) and f 2 (x,y) transforms machine instructions into a right affine mapping.

[0032] Figure 7E A left affine mapping 760 is shown, which is a function of two variables x, y and a stop attractor 770. The explicit calculation represented as two functions g 1 (x,y) and g 2 (x,y) transforms machine instructions into a left affine mapping.

[0033] Figure 8A A piecewise linear approximation of the S-shaped curve function is shown. In a machine learning embodiment of executing meta-instructions and random instructions ( Figure 9A) The S-shaped curve function is used in []. 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).

[0034] Figure 8B Shows a piecewise linear approximation of an almost step function 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). In a machine learning implementation of executing meta-instructions and random instructions ( Figure 9A ) The almost step function is used.

[0035] Figure 8C Shows a network of S-shaped curve functions used in a machine learning implementation. Some implementations have 2 or 3 layers of S-shaped curve functions connected by linear weighted sums. Some implementations have 100 layers of S-shaped curve functions. Some implementations have more than ten thousand layers of S-shaped curve functions. Some implementations have more than one million layers of S-shaped curve functions.

[0036] Figure 8D Shows a network of S-shaped curve functions and almost step functions used in a machine learning implementation. Some implementations have 2 or 3 layers of S-shaped curve functions connected by linear weighted sums. Some implementations have 100 layers of S-shaped curve functions and almost step functions. Some implementations have more than ten thousand layers of S-shaped curve functions and almost step functions. Some implementations have more than one million layers of S-shaped curve functions and almost step functions.

[0037] Figure 8E Shows a multi-layer network of non-linear functions used in a machine learning program 9A. In an implementation, the input of the node function is the weighted sum of the functions from the previous layer.

[0038] Figure 9A Illustrates a non-algorithmic machine learning program using machine instruction 900, which includes random instruction 920, meta-instruction 930, and standard instruction 940. The machine learning program is initially machine learning program 910. The random instruction 920 and the meta-instruction 930 enable the initial machine learning program 910 to self-modify during the process of computing to the developed machine learning program 950. Detailed Description

[0039] ex-machine computer

[0040] 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 defining the quantum random instruction and the meta-instruction, we first introduce some preliminary notations and specifications for the standard instruction.

[0041] Represents an integer. and are non-negative integer and positive integer respectively. The finite set represents Figure 1A the machine state 114 in Figure 1C and Figure 1D are shown in, where, after executing the first meta-instruction, the machine state 8 is added to the machine state 114 (step 1).

[0042] Let where each a i represents a different memory value 118 stored in the memory 116, denoted as T. The set includes alphabetic symbols (memory values) where # is a blank symbol, is the empty set. In some ex-machines, A = {0, 1, #, Y, N, a}, where a 1 = Y, a 2 = N, a 3 = a. In some ex-machines, A = {0, 1, #}, where is the empty set. Read from and write to the memory value in the memory (T). The ex-machine memory 116 is represented by the function T: With the additional condition that before the execution of the ex-machine begins, there exists N > 0 such that T(k) = # when │k│> N at this time. In other words, this mathematical condition means that all memory addresses, except for a finite number of them, contain blank or non-existent memory values. When this condition applies to memory 116, we say that the memory T is bounded.

[0043] Standard instruction

[0044] Machine specification 5.1. Figure 1A The execution of standard instruction 110 in

[0045] The standard ex-machine instruction <S satisfies and the uniqueness condition: If and and then q 1 ≠ q 2 or α 1 ≠ α 2 . The standard instruction I = (q, a, r, a, y) is similar to the Turing machine tuple [7, 33]. When the ex-machine is in state q and the storage head scans the memory value a = T(k) at memory address k, the instruction I is executed as follows:

[0046] · The state of the ex-machine moves from state q to state r.

[0047] · The ex-machine replaces the memory value a with the memory value α, so T(k) = α. The rest of the memory remains unchanged.

[0048] · If y = -1, the ex-machine moves its storage head, points one memory cell to the left (lower part) in the memory, and then scans the memory value T(k - 1) at memory address k - 1.

[0049] · If y = +1, the ex-machine moves its storage head, points one memory cell to the right (upper part) in the memory, and then scans the memory value T(k + 1) at memory address k + 1.

[0050] · If y = 0, the ex-machine does not move its storage head, and then scans the memory value T(k) = α at memory address k.

[0051] · If y = 0, the ex-machine does not move its storage head and then scans the memory value T(k) = α at memory address k.

[0052] · If y = 0, the ex-machine does not move its storage head and then scans the memory value T(k) = α at memory address k.

[0053] In other embodiments, Figure 1AThe standard instructions 110 in [the context] can be expressed in C syntax, such as x = x + 1; or z = (x + 1) * y;. In some embodiments, one of the standard instructions 110 can be a loop with a machine instruction body, such as:

[0054]

[0055] In some embodiments, the random instruction 140 can measure a random bit, called random_bit, and then execute non-deterministically according to the following code:

[0056]

[0057] In other embodiments, the standard instructions 110 can have programming language syntax, such as assembly language, C ++ , Fortran, JAVA, JAVA virtual machine instructions, Go, Haskell, RISC machine instructions, Ruby, LISP and execute on the hardware 204 as Figure 2A shown. In other embodiments, the standard instruction 110 can read the hexadecimal memory address 0x54E9A701285674FB41DEC7406382936A, and after executing one instruction, during a second computational step, the instruction can read the hexadecimal memory address 0x9A2368895EDC0523415E8790738293B8: Random access memory is available in the memory system 246 of Figure 2B . In some embodiments, the random access of the memory also implies that the standard instructions 110 can have programming language syntax, such as assembly language, C ++ , Fortran, JAVA, JAVA virtual machine instructions, Go, Haskell, RISC machine instructions, Ruby, LISP or a hardware data flow language, such as VHDL

[25] .

[0058] A digital computer program

[17] or a Turing machine

[24] has a fixed set Q of machine states, a finite alphabet A, a memory with finite bounds, and a finite set of standard ex-machine instructions executed according to specification 5.1. In other words, an ex-machine that only uses standard instructions is computationally equivalent to a digital computer

[17] . An ex-machine that only has standard instructions is called a standard machine or a digital computer. A standard machine has no unpredictability because it does not contain random instructions. A standard computer does not modify its instructions when performing calculations.

[0059] Random instruction

[0060] If each trial has only two possible outcomes (i.e., the random measurement 130 in FIG. 130) and the probability of each outcome remains constant for all trials, then the repeated independent trials are called random Bernoulli trials [9]. In an embodiment, the outcome is the result of measuring quantum event 170, quantum event 547, quantum event 557, or quantum event 565. Unbiasedness means that the probabilities of the two outcomes are the same. The random or non-deterministic property can be expressed in the following mathematical way.

[0061] Random measurement property 1. Unbiasedness test.

[0062] Consider the infinite product space {0, 1} N of bit sequences (x 1 x 2 …). The individual outcome x 1 x 2 … of the bit sequence generated by randomness is unbiased. The probability of measuring 0 or 1 is equal: i

[0063]

[0064] Random measurement property 2. Random independence.

[0065] The history has no influence on the next random measurement. Each outcome X i is independent of the history. There is no correlation between previous or future outcomes. This is expressed in terms of conditional probability: and for every b i ∈ {0, 1}.

[0066] In some embodiments, the randomness generator 160 used by the random instructions 140, 150 has measurement properties 1 and 2. In some embodiments, Figure 5A the randomness generator 542 in Figure 5C has measurement properties 1 and 2. In other embodiments, when measured by a physical device, the physical device constructed with a quantum observable according to Figure 5C exhibits properties 1 and 2. In some embodiments, electrons can provide a source of spin - 1 for quantum event 565, as shown in Figure 6A In some embodiments, Figure 6B the photons in LED 610 in Figure 6B LED 620 in Figure 6B or LED 630 in LED 6C can provide a source of quantum events 170, 547, or 557, which are measured by the random measurement 130 and detected by the phototransistor 544 or the photodiode 554. Section 6 provides a physical basis for the measurement properties and a discussion of quantum randomness for certain embodiments of non - determinism.

[0067] The random instruction R is a subset of Q × Q × Q × {−1, 0, 1} = {(q, a, r, y) : q, r ∈ Q and a ∈ A and y ∈ {−1, 0, 1}}, which satisfies the uniqueness condition defined below.

[0068] Machine specification 5.2.

[0069] Figure 1A Execution of random instruction 140 in

[0070] In some embodiments, the random instruction R satisfies and the following uniqueness condition: If and and (q 1 , α 1 , r 1 , y 1 ) ≠ (q 2 , α 2 , r 2 , y 2 ), then q 1 ≠ q 2 or α 1 ≠ α 2 . When the machine head reads the memory value a from the memory T and the machine is in the machine state q, the random instruction (q, a, r, y) is executed as follows:

[0071] 1. The machine reads the random measurement 130, which returns a random bit b ∈ {0, 1}.

[0072] 2. In the memory, the memory value a is replaced by the random bit b (which is why A contains both the symbols 0 and 1).

[0073] 3. The machine state changes to the machine state r.

[0074] 4. If y = −1, the machine moves its storage head to the left, if y = +1, it moves to the right, or if y = 0, the storage head does not move.

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

[0076] In some embodiments, the quantum measurement satisfies the random measurement property 1 and the random measurement property 2. In some embodiments, the random measurement 130 is implemented using the Figure 5A randomness generator 542 therein. In some embodiments, the quantum random measurement 130 measures the quantum event 565 using a spin-1 source 560 (e.g., an electron), followed by an S z separator 570, and then an S x separator 580, as Figure 5C shown. In some embodiments, Figure 6A the LED 610 in Figure 6B or the LED 620 in Figure 5A or the photons from the LED 630 in 6C can provide the source of the quantum event 547 or quantum 557 measured by the random measurement 130, which uses the phototransistor 544 or the photodiode 554 as the detector of the quantum event. In some embodiments,

[0077] In some embodiments, there are more than two results for the physical measurement performed by the random measurement 130. For example, 8 different results can be generated by repeating 3 measurements using a spin-1 source 560 (e.g., an electron), followed by an S z separator 570, and then an S x separator 580, as Figure 5C shown. These 3 measurements produce 3 bits, which represent 2 3= 8 possible outcomes. In an embodiment, there are three outcomes. In another embodiment, there are four different outcomes.

[0078] In an embodiment, after executing a random instruction, at step 4, the machine can randomly access different parts of the memory. For example, before executing the random instruction, it might be reading memory address 0x4B6368895EDC0543418E8790738293B9, and after step 4, it will move to reading memory address 0x29F2B761285674FB41DE074063529462.

[0079] Machine instruction 1 lists a random walk machine with only standard instructions and random instructions. The alphabet A = {0, 1, #, E}. The states are Q = {0, 1, 2, 3, 4, 5, 6, h}, where the stop state h = 7. The valid initial memory contains only blank symbols; i.e., . The valid initial state is 0.

[0080] There are 3 random instructions: (0, #, 0, 0), (1, #, 1, 0), and (4, #, 4, 0). First, the random instruction (0, #, 0, 0) is executed. If the random source measures 1, the machine jumps to state 4, and the memory head moves to the right of memory address 0. If the random source measures 0, the machine jumps to state 1, and the memory head moves to the left of memory address 0. Instructions containing the letter value E provide error checking for invalid initial memory or initial states; in this case, the machine stops due to an error.

[0081] Machine specification 1. Random walk

[0082] ;; Comments follow two semicolons.

[0083] (0, #, 0, 0)

[0084] (0, 0, 1, 0, -1)

[0085] (0, 1, 4, 1, 1)

[0086] ;; Continue the random walk to the left of memory address 0

[0087] (1, #, 1, 0)

[0088] (1, 0, 1, 0, -1)

[0089] (1, 1, 2, #, 1)

[0090] (2, 0, 3, #, 1)

[0091] (2, #, h, E, 0)

[0092] (2,1,h,E,0)

[0093] ;; Return status 0. The number of random 0s = the number of random 1s.

[0094] (3,#,0,#,-1)

[0095] ;; Return status 1. The number of random 0s > the number of random 1s.

[0096] (3,0,1,0,-1)

[0097] (3,1,h,E,0)

[0098] ;; Continue the random walk to the right of memory address 0

[0099] (4,#,4,0)

[0100] (4,1,4,1,1)

[0101] (4,0,5,#,-1)

[0102] (5,1,6,#,-1)

[0103] (5,#,h,E,0)

[0104] (5,0,h,E,0)

[0105] ;; Return status 0. The number of random 0s = the number of random 1s.

[0106] (6,#,0,#,1)

[0107] ;; Return status 4. The number of random 1s > the number of random 0s.

[0108] (6,1,4,1,1)

[0109] (6,0,h,E,0)

[0110] The following are 31 computational steps for the first execution of the ex-machine. When the initial memory is blank and the initial state is 0, this random walk machine never stops. As Figure 1A part of the random instruction 140 in

[0111] The 1st execution of the random walk machine. Computational steps 1 - 31.

[0112]

[0113]

[0114] The following are the first 31 steps of the second execution of the ex-machine. As Figure 1A part of the random instruction 140 in, the first random instruction executed is (0, #, 0, 0). The random bit measured by the random measurement 130 is 1, so the result of this instruction is shown as (0, #, 0, l_qr, 0). The second random instruction executed is (1, #, 1, 0), and its measurement is 0, so the result of this instruction is shown as (1, #, 1, 0_qr, 0).

[0115] The second execution of the random walk machine. Calculate steps 1 - 31.

[0116]

[0117]

[0118] The first and second executions of the random walk ex-machine verify our statement in the introduction: Contrary to standard machines or digital computers, the execution behavior of the same ex-machine can be different in two different situations, even if each instance of the ex-machine starts its execution with the same input, the same initial state, and the same initial instructions stored in the memory. Therefore, the ex-machine is a discrete non-autonomous dynamic system that can enhance its computing power.

[0119] Meta-instruction

[0120] A meta-instruction is a second type of special instruction, as Figure 1A shown in 120. The execution of a meta-instruction enables the ex-machine to self-modify its instructions. This means that when executing Figure 1A the ex-machine instruction 100, the meta-instruction of the ex-machine can add new states, add new instructions, or replace instructions. Formally, the meta-instruction satisfies and r ∈ Q ∪ {|Q|} and a, α ∈ A and the instruction is part of the self-modifying system 250 ( Figure 2B ) when executed in the processor system 252. In an implementation, the processor system 252 is implemented in the Figure 2A machines 204, 214, 216, 218, 220.

[0121] Definition as stored in the storage system 246 ( Figure 2B ) Figure 1AThe set of standard instructions 110, random instructions 140, and meta-instructions 120. To assist in describing how the meta-instructions modify Figure 2B The I in the self-modifying system 250 defines unique states and scanning symbol conditions. For any two different instructions selected from at least one of the first two coordinates should be different, so that Figure 2B the processor system 252 in can determine which machine instruction 100 to execute next. More precisely, all of the following 6 uniqueness conditions apply to the instructions 110, 120, and 140 stored in the hardware storage system 246 ( Figure 1A , 1B , 1C, 1D).

[0122] 1. If (q 1 , α 1 , r 1 , β 1 , y 1 ) and (q 2 , α 2 , r 2 , β 2 , y 2 ) are both in S, then q 1 ≠q 2 or α 1 ≠α 2 .

[0123] 2. If and then q 1 ≠q 2 or α 1 ≠α 2 .

[0124] 3. If (q 1 , α 1 , r 1 , y 1 ) and (q 2 , α 2 , r 2 , y 2 ) are both in then q 1 ≠q 2 or α 1 ≠α 2 .

[0125] 4. If and then q 1 ≠q 2 or α 1 ≠α 2 .

[0126] 5. If and then q 1 ≠q 2 or α 1 ≠α 2 .

[0127] 6. If (q 1 , α 1 , r 1 , a 1 , y 1 , J 1 ) and (q 2 , α 2 , r 2 , a 2 , y 2 , J 2 ) are all in M, then q 1 ≠q 2 or α 1 ≠α 2 .

[0128] Before the start of effective machine execution, the hardware machine (as shown in the system of Figure 2B )

[0129] should be designed such that standard instructions, quantum random instructions, and meta-instructions always satisfy the unique state, scanned symbol condition. This condition ensures that there is no ambiguity about which machine instruction should be executed when the machine is in state q and scanning symbol a in the memory. Ambiguity can lead to physical situations where no more instructions are executed: this is similar to a flip-flop that has not yet determined its 0 or 1 output (i.e., indecisive). In addition, the execution of meta-instructions preserves this uniqueness condition.

[0130] Specification 5.3 is Figure 2B the implementation of the self-modifying system 250 in Figure 1A . Specification 5.3 is also

[0131] Machine Specification 5.3. Figure 1A The execution of the meta-instruction 120 in

[0132] M. The meta-instruction (q, a, r, a, y, J) is executed as follows.

[0133] · The first 5 coordinates (q, a, r, a, y) are executed as standard instructions according to Specification 5.1, with one caveat. The state q can be expressed as |Q| - c 1 and

[0134] the state r can be expressed as |Q| or |Q| - c 2 , where 0 < c 1, c 2 ≤ |Q|. When (q, a, r, a, y) is executed, if q is expressed as |Q| - c 1 , then the value of q is instantiated as the current value of |Q| minus c 1 . Similarly, if r is expressed as |Q| or |Q| - c 2 , then the value of state r is instantiated as |Q| or the current value of |Q| minus c 2 .

[0135] · Subsequently, instruction J modifies I, where instruction J has one of three forms: J = (q, a, r, a, y) or J = (q, a, r, y) or

[0136] J = (q, a, r, α, y, J 1 ). In the third form, J is also a meta-instruction.

[0137] · For each of these three forms, if the unique state and scanned symbol conditions are still satisfied, then is updated to

[0138] · Otherwise, there exists an instruction I in whose first two coordinates q, a, are equal to the first two coordinates of instruction J. In this case, instruction J replaces the instruction I in

[0139] . That is, is updated to

[0140] In the third form, in the meta-instruction 120 of Figure 1A , the executed meta-instruction can create a new meta-instruction, which is added to I according to the unique state and scanned symbol conditions or replaces some other instruction already located in . The meta-instruction that creates another meta-instruction can also be part of the self-modifying system 250. Regarding Specification 5.3, Embodiment 1 shows how instruction I is added to and how a new state is instantiated and added to Q.

[0141] Machine Embodiment 1. Adding a new machine state

[0142] Consider the meta-instruction (q, a 1 , |Q| - 1, α 1 , y 1 , J), where J = (|Q| - 1, a 2 , |Q|, α 2 , y 2 ). In the standard instruction (q, a1 , |Q| - 1, α 1 , y 1 ) After being executed, this meta-instruction adds a new state |Q| to the machine state Q and also adds the instruction J, instantiated with the current value of |Q|. Figure 1C Shows the execution of the first computational step of this meta-instruction — for the specific values Q = {0, 1, 2, 3, 4, 5, 6, 7}, A = {#, 0, 1}, q = 5, a 1 = 0, α 1 = 1, y 1 = 0, a 2 = 1, α 2 = #,, and y 2 = -1. The state and memory values are shown in red and blue respectively.

[0143] Figure 1D Shows the execution of the second computational step of the meta-instruction (q, a 1 , |Q| - 1, α 1 , y 1 , J), where J = (|Q| - 1, a 2 , |Q|, α 2 , y 2 ). Figure 1C And Figure 1D Illustrates how a new machine state is added to Q as a result of executing the meta-instruction.

[0144] In other embodiments, Figure 1A the meta-instruction 120 in Figure 2B can be implemented in hardware that is capable of counting the number of machine states and has instantiation hardware to instantiate the meta-instruction based on the current number of machine states. In the hardware, the additional instructions created by executing the meta-instruction can be stored in this hardware, thus implementing Figure 1A the storage system 246 of Figure 2A . In other embodiments, the meta-instruction 120 in Figure 5B can be implemented in a more abstract programming language. In some embodiments, the meta-instruction 120 can be implemented in the LISP programming language and executed on the Figure 6A shown computer machine 204, where Figure 6B the external random number generator 552 in Figure 6C has an LED as the quantum source, as shown in

[0145] The following shows how to express in LISPFigure 1A An embodiment of the meta-instruction 120 in. 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 the lambda function y_plus_x, which is expressed as (lambda (y x) (+ y x)) to construct the lambda function (lambda (x) (+ x x)) which takes one argument x as input and doubles x.

[0146]

[0147]

[0148] In the final calculation step, the lambda function (lambda (x) (+ x x)) is returned.

[0149] Let X be the ex-machine. The instantiation of |Q|-1 and |Q| in meta-instruction I ( Figure 1C as shown) calls for self-reflection related to the number of current states of when executing I. This simple type of self-reflection is straightforward in physical implementation. In particular, the physical implementation in our laboratory, together with the quantum random bits measured from a quantum random number generator

[34] , simulates all the executions of the ex-machine provided in this article.

[0150] Machine specification 5.4. Simple meta-instruction

[0151] The simple meta-instruction has one of (q, a, |Q|-c 2 , α, y), (q, a, |Q|, α, y), (|Q|-c 1 , a, r, α, y), (|Q|-c 1 , a, |Q|-c 2 , α, y), (|Q|-c 1 , a, |Q|, α, y), where 0 < c 1 , c 2 ≤|Q|. When the instruction is executed, the expressions |Q|-c 1 , |Q|-c 2 and |Q| are instantiated to states based on the current value of |Q|.

[0152] In the implementation in this section, the ex-machine only utilizes the self-reflection of the symbols |Q|-1 and |Q|. In other implementations, the ex-machine can utilize the self-reflection of |Q|+c, where c is a positive integer.

[0153] Machine implementation 2. Execution of the simple meta-instruction ​

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

[0155] (|Q| - 1, #, |Q| - 1, 1, 0)

[0156] (|Q| - 1, 1, |Q|, 0, 1)

[0157] (|Q| - 1, 0, |Q|, 0, 0)

[0158] With an initial blank memory and a starting state of 0, the first four computational steps are as follows. In the first step, the storage head scans # and the ex - machine state is 0. Since |Q| = 1, the simple meta - instruction (|Q| - l, #, |Q| - 1, 1, 0) instantiates to (0, #, 0, 1, 0) and is executed.

[0159]

[0160] In the second step, the storage head scans 1 and the state is 0. Since |Q| = 1, the instruction (|Q| - 1, l, |Q|, 0, 1) instantiates to (0, 1, 1, 0, 1), is executed and updated to Q = {0, 1}. In the third step, the storage head scans # and the state is 1. Since |Q| = 2, the instruction (|Q| - 1, #, |Q| - 1, 1, 0) instantiates to (1, #, 1, 1, 0) and is executed. In the fourth step, the storage head scans 1 and the state is 1. Since |Q| = 2, the instruction (|Q| - l, 1, |Q|, 0, 1) instantiates to (1, 1, 2, 0, 1), is executed and updated to Q = {0, 1, 2}. In these four steps, two simple meta - instructions create four new instructions and add new states 1 and 2.

[0161] Machine Specification 5.5. Finite Initial Conditions

[0162] Before the machine starts execution, if Figure 1A 、 Figure 2A 、 Figure 2B 、 Figure 5A 、 Figure 5B 、 Figure 5C 、 Figure 6A 、 Figure 6B 、 Figure 6C the computational hardware as shown in the hardware implementation of satisfies the following conditions, then the machine is considered to have finite initial conditions.

[0163] 1. The number of machine states |Q| is finite.

[0164] 2. The number of alphabet symbols |A| (i.e., memory values) is finite.

[0165] 3. The number of machine instructions is finite.

[0166] 4. The memory is finite - bounded.

[0167] It may be useful to consider the initial conditions of the ex - machine similar to the boundary - value conditions of differential equations. Although easy to verify, the purpose of Remark 5.1 is to ensure that computations are performed on different types of hardware via the ex - machine, such as semiconductor chips, lasers using photons, biological implementations using proteins, DNA, and RNA, and quantum computers using entanglement and quantum superposition.

[0168] Remark 5.1. Finite initial conditions

[0169] If the machine starts its execution with finite initial conditions, then after the machine executes l instructions for any positive integer l, the current number of states Q(l) is finite and the current set of instructions I(l) is finite. Moreover, the memory T remains finite - bounded, and the number of measurements obtained from random or non - deterministic sources is finite.

[0170] Proof. This 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 a meta - instruction adds at least one new instruction and one new state to Q.

[0171] Specification 5.6 describes a new ex - machine that can evolve from the computation of a previously stopped ex - machine. The concept of evolution is useful because the random instruction 140 and the meta - instruction 120 can self - modify the instructions of the ex - machine during execution. In contrast to an ex - machine, after a digital computer program stops executing, its instructions remain unchanged.

[0172] This difference motivates the next specification, as follows. Consider an initial ex - machine with 9 initial states and 15 initial instructions starting execution on a finite - bounded memory T 0 and stopping. When the ex - machine stops, it (now called ) has 14 states and 24 instructions and the current memory is S 1 . We say that the ex - machine 0 with memory T evolves into the ex - machine 1 with memory S Machine Specification 5.6. Evolving ex - machine

[0173] Let T 0 、T 1 、T2 ...T i-1 Each in...T is a memory with a finite boundary. Consider the ex-machine which has a finite initial state in ex-hardware. to execute the memory T 0 starting and developing into an ex-machine with memory S1 Subsequently, utilizing the memory T 1 starting to execute and developing into an This means that when the ex-machine starts to execute on the memory T 1 its instructions utilize S after stopping 1 and are saved. The ex-machine continues to develop until starting to utilize the memory T i-1 executing and developing into an ex-machine with memory S i of It can be said that the ex-machine utilizes the memory T with a finite boundary 0 、T 1 、T 2 ...T i-1 develops into an ex-machine after i stops

[0174] When the ex-machine develops into and subsequently develops into and so on until the ex-machine then the ex-machine is called the prototype of the ex-machine whenever 0 ≤ i < j ≤ n. Similarly, the ex-machine is called the descendant of the ex-machine whenever 0 ≤ i < j ≤ n. The sequence of ex-machines is called the development path.

[0175] In some embodiments, this sequence of ex-machines can be stored on different computing hardware, such as Figure 2A shown by machines 214, 216, 218, and 220. In an embodiment, the token 202 can contain Figure 5A 、 Figure 5B 、 Figure 5C 、 Figure 6A 、 Figure 6B or Figure 6C shown hardware. The token 202 can provide a quantum random measurement 130 or assist in implementing Figure 2Aused by machines 214, 216, 218, and 220 Figure 1B random instruction 150 in

[0176] 6 Non-determinism, Randomness, and Quantum Events

[0177] In some embodiments, the computer machines described in the present invention use non-determinism as a computational tool to make the computation unpredictable. In some embodiments, quantum random measurements are used as computational tools. Based on the measurement of quantum event 170 by randomness generator 160, quantum randomness is a type of non-determinism, as Figure 1B shown.

[0178] We performed DIEHARD statistical tests on our random instructions executed in random walk embodiment 1, the implementation of which follows Figure 6A , Figure 6B and Figure 6C shown embodiments. The statistics of our random instructions executed in random walk embodiment 1 behave according to random measurement attributes 1 and 2. These statistical attributes have also been empirically observed in other quantum random sources [22, 26, 27].

[0179] 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 semi-transparent mirror and then take two or more paths in space. In one embodiment, if the photon is reflected by the semi-transparent mirror, it has a bit value b, with a binary result: if the photon passes through the semi-transparent mirror (i.e., quantum event 170), the non-deterministic process produces another bit value b.

[0180] In another embodiment, the spin 560 of an electron can be measured to generate the next non-deterministic bit. In another embodiment, a protein composed of amino acids with two or more conformations ( Figure 1B quantum event 170 in Figure 1B quantum event 170) across a cell membrane or an artificial membrane can be used to detect non-determinism: the protein conformation (quantum event 170) measured by random measurement 130 can generate non-deterministic values in {0, 1, n1}, where the protein has n different conformations. In an alternative embodiment, one or more rhodopsin proteins can be used to detect the arrival time of photons ( 0 <t 1 <t 2 can generate non-deterministic bits: generate 1 if t 2 -t 1 >t 1 -t 0; and generate 0 if t 2 -t 1 <t 1 -t 0 ; and do not generate a bit if t 2 -t 1 =t 1 -t 0 。In some embodiments, a Geiger counter may measure the detection of radioactive events (quantum event 170) as part of a randomness generator 160, which is part of random instructions 150.

[0181] In Sections 7 and 12, the execution of standard instructions, random instructions, and meta-instructions uses the following property: for any m, when the quantum random number generator makes m binary measurements, all 2 m binary strings are equally likely to occur. However, it must be noted not to misinterpret quantum random properties 1 and 2. In an embodiment, in the case where the probability of a single binary result is , then a simple standard machine can be used to generate an unbiased source of randomness (i.e., each binary string is equally likely), and the standard machine operates on more than one measurement of the binary result to produce a single unbiased result. The number of measurements by random measurement 130 required to generate an unbiased binary result depends on how far p is from frac12.

[0182] Considering the Champernowne sequence 01 00 01 10 11 000 001 010 011 100 101 110 111 0000... (sometimes referred to as a Borel normal sequence) can still be Turing computable. In [9], Feller discussed the mathematics of random walks. The Champernowne sequence is very poor in terms of the expected number of sign changes of a random walk as n → ∞. Since all 2 m strings are equally likely, the expected value of the sign change follows the reflection principle and simple counting arguments, as shown in Section III.5 of [9].

[0183] In addition, 2 mMost of the binary strings (i.e., binary strings of length m) have a high Kolmogorov complexity. This fact leads to the following mathematical intuition, enabling new computational behaviors that cannot be performed by standard digital computers. The execution of quantum random instructions working with meta-instructions enables an ex-machine to increase its program complexity as it evolves

[28] . In some cases, the increase in program complexity can increase the computational power of the ex-machine as it evolves. Additionally, note the difference between the program complexity and the Kolmogorov complexity of the ex-machine here. The definition of Kolmogorov complexity only applies to standard machines. Moreover, for standard machines, the program complexity (e.g., Shannon complexity |Q||A|) remains fixed. In contrast, when an ex-machine executes quantum random and meta-instructions that work effectively together, the program complexity of the ex-machine increases infinitely. (For example, see ex-machine 2, called (a;).)

[0184] Regarding the ex-machine computations performed, how to generate one of these binary strings from a certain type of non-deterministic process is not a crucial issue. Suppose a quantum random generator demonstrates the measurement of particle spin, and it is proven by the strong Kochen-Specker theorem [4, 13] that the 100-bit string α 0 α 1 ...α 99 = 1011000010101111001100110011100010001110010101011011110000000010011001000011010101101111001101010000 is output to the ex-machine

[0185] Suppose the same 100-bit string α 0 α 1 ...α 99 is output to a unique ex-machine using a unique quantum randomness generator of radioactive decay Suppose and have equivalent programs with the same initial tape and the same initial state. Although radioactive decay was discovered over 100 years ago and its physical basis remains phenomenological, the execution behaviors of and do not differ for the first 100 executions of their quantum random instructions. In other words, the ex-machines and Shows the execution behavior independent of the quantum process that generates these two equivalent binary strings. 6.1 Mathematical determinacy and unpredictability

[0186] Before reviewing some deeper theories about quantum randomness, let's take a step back and look at randomness from a broader theoretical perspective. Although we generally agree with Eagle [7]'s philosophy that randomness is unpredictability, Implementation 3 helps to exacerbate the difference between uncertainty and unpredictability.

[0187] Machine Implementation 3.

[1111] Gedanken mathematical experiment

[0188] Our gedanken experiment demonstrates a deterministic system that exhibits great unpredictability. This implementation shows that if the measurement of a process has finite resolution, then a physical system whose mathematics is deterministic can still be an extremely unpredictable process. Before introducing the gedanken experiment, some mathematical work is needed to define the dynamical system and summarize its mathematical properties.

[0189] Consider the quadratic graph Let and Let Define the set 0 is a fixed point of f and so the boundary points of B lie in A. Moreover, whenever x ∈ B, then f(x) < 0 and This means that all orbits leaving A head towards —∞.

[0190] The inverse image f -1 (B) is two open intervals and such that f(B 0 ) = f(B 1 ) = B. Topologically, B 0 behaves like Cantor's open middle third I 0 , and B 1 behaves like Cantor's open middle third I 1 . Repeating the inverse image infinitely, define the set Now

[0191] Using dynamical system notation, let Define the shift map σ: ∑ 2 → ∑ 2 , where σ(a 0 a 1 ...) = (a 1 a 2...) For each x in Λ, the trajectory of x in I 0 in I 1 corresponds to a unique point in ∑ 2 : Define h: h: Λ → ∑ 2 by h(x) = (a 0 a 1 ...) such that for each Let a n = 0 if f n (x) ∈ I 0 and a n = 1 if f n (x) ∈ I 1 .

[0192] For any two points (a 2 a 0 a 1 ...) and (b 0 b 1 ...) in ∑ By introducing the standard topology on K that induces a subspace topology on Λ, it can be easily verified that h is a homeomorphism from Λ to ∑ 2 .

[0193] Furthermore, Therefore, h is a topological conjugation. The set H and the topological conjugation 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 Λ.

[0194] We are ready to present our mathematical gedanken experiment. We make the following assumptions about our mathematical observer. When our observer makes a physical measurement of x in Λ 2 , if x lies in I 0 , then she measures 0, while if x lies in I 1 , then she measures 1. We assume that she cannot make her observations more accurate in an idealized way similar to the following: Due to the wavelike properties of matter, measurements at the quantum level have a finite resolution [3]. Similarly, in a second observation, if f(x) lies in I 0 , then our observer measures 0, and if f(x) lies in I 1 , then she measures 1. Our observer continues these observations until she measures whether f k-1 (x) is in I 0 or in I 1 . Before making her k + l-th observation, can our observer tell whether f k (x) lies in I 0 or in I1 Make a valid prediction with an accuracy rate exceeding 50% in?

[0195] When h(x) is ∑ 2 a generic point in (i.e., with respect to the Lebesgue measure), the answer is no. Let be a ∑ 2 in random point. Then has Lebesgue measure 1 in ∑ 2 (Feller [9]), and thus its complement has Lebesgue measure 0. For any x such that h(x) lies in , then our observer cannot use a Turing machine to predict the orbit of x. Thus, through the topological conjugation h, we see that for a generic point x in Λ, the orbit of x between I 0 and I 1 is Martin-Löf random - even though f is mathematically deterministic and f is a Turing-computable function.

[0196] Furthermore, the dynamical system (f, Λ) is mathematically deterministic and every real number x in Λ has a finite value. However, due to the lack of resolution in the observer's measurement, the orbit of the generic point x is unpredictable - in terms of randomness.

[0197] 6.2 Quantum randomness theory

[0198] The standard theory of quantum randomness originated from the groundbreaking EPR paper [8]. Einstein, Podolsky, and Rosen (EPR) proposed the necessary conditions for a complete theory of quantum mechanics: every element of physical reality must have a counterpart in a physical theory. In addition, they pointed out that the elements of physical reality must be found through the results of experiments and measurements.

[0199] While mentioning that there may be other ways to identify physical reality, EPR proposed the following as a reasonable criterion for a complete theory of quantum mechanics:

[0200] If, without in any way disturbing a system, the value of a physical quantity can be predicted with certainty (i.e., the probability equals 1), then there exists an element of physical reality corresponding to that physical quantity.

[0201] They considered the quantum mechanical description of a particle with one degree of freedom. After some analysis, they concluded that for a For a particle in a given state, the determined value of the coordinate is unpredictable and can only be obtained through direct measurement. However, such a measurement will interfere with the particle and change its state. They remind us that in quantum mechanics, when the momentum of a particle is known, its coordinate has no physical reality. This phenomenon has a more general mathematical condition, that is, if the operators corresponding to two physical quantities (such as A and B) do not commute, then the precise knowledge of one will prevent the precise knowledge of the other. Therefore, EPR arrives at the following conclusion:

[0202] (I) The quantum mechanical description of physical reality given by the wave function is incomplete. Or

[0203] (II) When the operators corresponding to two physical quantities (for example, position and momentum) do not commute (i.e., AB≠BA), these two quantities cannot simultaneously have the same reality.

[0204] EPR justifies this conclusion through the following reasoning: If two physical quantities simultaneously have reality and thus have determined values, then these determined values will be part of the complete description. In addition, if the wave function provides a complete description of physical reality, then the wave function will contain these determined values, and these determined values are predictable.

[0205] Based on their conclusion of I or II, EPR assumes the opposite of I - the wave function does give a complete description of physical reality. They analyzed two systems that interacted within a finite time interval. And through a thought experiment of measuring each system by reducing the wave packet, they showed that two different wave functions can be assigned to the same physical reality. After further analyzing the two wave functions of the eigenfunctions of two non - commuting operators, they concluded that two physical quantities with non - commuting operators can simultaneously have reality. From this contradiction or paradox (depending on one's perspective), they concluded that the quantum mechanical description of reality is incomplete.

[0206] In [2], Neil Bohr responded to the EPR paper. By analyzing experiments involving single - slit experiments and double - slit experiments (two or more), Bohr explained how momentum is transferred between the observed object and the measuring device during position measurement. Similarly, Bohr explained that the object will shift during momentum measurement. Bohr had a similar view on time and energy: "In principle, it is excluded to control the energy entering the clock without essentially disturbing its use as a time indicator". Because it is impossible to control the interaction between the observed object and the measuring device at the quantum level, Bohr advocated "finally abandoning the classical ideal of causality" and "a radical modification of physical reality".

[0207] Bohr concluded from his experimental analysis that without disturbing the system in any way, the meaning of the EPR expression became ambiguous in their argument. Bohr pointed out: "Essentially, there is a problem regarding the influence of extraordinary conditions that define the types of possible predictions about 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 appropriately attached, we see that the argument of the above authors does not justify their conclusion that the description of quantum mechanics is essentially incomplete." Overall, EPR and the Bohr - Born - Heisenberg position laid the foundation for understanding whether there are hidden variables in the quantum mechanics theory.

[0208] The implementation of quantum random instructions makes use of the lack of hidden variables, as this leads to the unpredictability of quantum random measurements. In some implementations of the quantum random measurements used in quantum random instructions, the lack of hidden variables is only associated with the quantum system being measured, and in other implementations, the lack of hidden variables is associated with the measuring device. In some implementations, the non - deterministic indication of the value of the observable implies unpredictability. In some implementations, the unpredictability of the quantum measurement value 130 in the figure depends on the Kochen - Specker type theorem [4, 13]. In some implementations, Figure 1A the unpredictability of the random measurement value 130 in [ ] depends on the Bell type theorem [1].

[0209] In Figure 1A the implementation of the quantum random measurement 130 shown in Figure 5C a protocol for two consecutive measurements starting with a spin - 1 source is shown. The spin - 1 particle is prepared in the state Sz = 0. (According to its eigenstate hypothesis, the operator has a definite value.) Specifically, the first measurement places the particle in the eigenstate of the spin operator Sz with Sz = 0. Since the prepared state is the eigenstate of the projector of S x = 0 where the eigenvalue 0 can be observed, this result has a definite value and is theoretically unattainable. The second measurement is performed in the eigenbasis of the S x operator and has two results S x = ±1.

[0210] S x = ±1 results can be assigned 0 and 1 respectively. Additionally, since neither of the results Sx = ±1 can have a predetermined definite value. As a result, bits 0 and 1 are generated independently (random independence) with a 50 / 50 probability (unbiasedness). These are quantum random properties 1 and 2.

[0211] 7 Calculate ex - machine language

[0212] A class of ex - machines is defined as basic ex - machines (x) develops with its 15 initial instructions listed in ex - machine specification 2. These ex - machines compute the language L, which is a subset of. The expression a n represents a string of n consecutive a's. For example, a 5 = aaaaa and a 0 is the empty string. Define the language set

[0213]

[0214] Machine specification 7.1 defines a unique language for each function in .

[0215] Machine specification 7.1. The language L f

[0216] Consider any function This means that f is a member of the set {0, 1} N . The function f gives rise to the language L f = {a n : f(n) = 1}. In other words, for each non - negative integer n, the string a n is in the language L f if and only if f(n) = 1.

[0217] Most simply, L f is a language in. Additionally, these functions f generate all of the

[0218] Remarks 7.1.

[0219] To define the halting grammar of the language in computed by the ex - machine, choose the set of letters A = {#, 0, 1, N, Y, a}.

[0220] Machine specification 7.2. The language L in

[0221] Let be an ex - machine. The language L in computed by X is defined as follows. A valid initial tape has the form ##a n #. A valid initial tape represents the empty string. After the machine starts execution with the initial tape ##a n #, if the ex - machine halts with the tape #a n#Y# Stop then the string a n In the language of. If with #a n #N# Stop then the string a n not in the language of.

[0222] The use of the special alphabet symbols (i.e., special memory values) Y and N - for the purpose of determining whether a n is in the language - follows

[14] .

[0223] For a specific string ##a m #, some ex-machine X can first stop with #a m #N# and can stop with #a m #Y# in a second computation using the input ##a m #. This oscillation of the stop output may continue indefinitely and, in some cases, the oscillation may be non-periodic. In this case, according to machine specification 7.2, the language of, will not be well-defined. These types of ex-machines will not be specified in the present invention.

[0224] And there is a subtle difference between an ex-machine (whose stop output is never stable) and. Contrary to a Turing machine or a digital computer program, two different instances of an ex-machine can evolve into two different machines and compute different languages according to machine specification 7.2. However, in evolving into a new machine (a 0 a 1 ...a m x) as a result of a previous execution with the input tape ##a m #, then for each i where 0 ≤ i ≤ m, when presented with the input tape ##a i (a (a 0 a 1 ...a m x) always stops with the same output. In other words, (a 0 a 1 ...a m x) has a stable stop output for all input strings a i where 0 ≤ i ≤ m. Additionally the non-autonomous behavior using its two quantum random instructions makes Capable of developing languages that are Turing-incomputable (i.e., not computable by a standard digital computer).

[0225] We designed ex-machines that compute subsets of {a}* rather than subsets of {0,1}* because the resulting specifications are simpler and more concise. It is straightforward to list the standard machine that bijectively transforms each a n into a binary string in {0,1}*. The empty string in {a}* maps to the empty string in {0,1}*. Let ψ denote this transformation mapping. Thus, and so on. Similarly, the inverse transformation standard machine computes the inverse of ψ. Thus, and so on. The transformation and inverse transformation computations immediately transfer any result related to the computation of an ex-machine for a subset of {a}* to the corresponding subset of {0,1}* via ψ. In particular, the following remark is relevant to our discussion.

[0226] Remark 7.2. Each subset of {a}* can be computed by some ex-machine if and only if each subset of {0,1}* can be computed by some ex-machine.

[0227] Proof. This remark follows from the fact that the transformation mapping ψ and the inverse transformation mapping ψ -1 can be computed using standard machines.

[0228] When the quantum randomness in the two quantum random instructions satisfies Property 1 (unbiased Bernoulli trials) and the random measurement Property 2 (random independence), for each of the 2 n finite paths of length n—in Figure 3 the infinite binary tree of

[0229] —are equally likely. (For a comprehensive study of random walks, see [9].) and Figure 3 Moreover, there is a one-to-one correspondence between the infinite downward paths in the infinite binary trees of the functions and The starting point of a particular infinite downward path is shown in red; it starts with (0,1,1,0...). Based on the one-to-one correspondence between the function and the downward paths in the infinite binary tree, an examination of the execution behavior of shows that when the quantum random instructions (x,#,x,0) and (x,a,t,0) satisfy the random measurement Property 1 and the random measurement Property 2, f can be developed to compute any language L

[0230] Machine Specification 2.

[0231] A = {#, 0, l, N, Y, a}. The set of states Q = {0, h, n, y, t, v, w, x, 8}, where the halt state h = 1, and the states n = 2, y = 3, t = 4, v = 5, w = 6, x = 7. The initial state is always 0. Letters are used to represent the machine states rather than explicit numbers because these states have special purposes. (This is for the convenience of the reader.) When the state n represents "no", it means the string is not in the machine language. When the state y represents "yes", it means the string is in the machine language.

[0232] The 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 15 instructions are shown below.

[0233] (0, #, 8, #, l)

[0234] (8, #, x, #, 0)

[0235] (y, #, h, Y, 0)

[0236] (n, #, h, N, 0)

[0237] (x, #, x, 0)

[0238] (x, a, t, 0)

[0239] (x, 0, v, #, 0, (|Q| - 1, #, n, #, 1))

[0240] (x, 1, w, #, 0, (|Q| - 1, #, y, #, 1))

[0241] (t, 0, w, a, 0, (|Q| - 1, #, n, #, 1))

[0242] (t, 1, v, a, 0, (|Q| - 1, #, y, #, 1))

[0243] (v, #, n, #, 1, (|Q| - 1, a, |Q|, a, 1))

[0244] (w, #, y, #, 1, (|Q| - 1, a, |Q|, a, 1))

[0245] (w, a, |Q|, a, 1, (|Q| - 1, a, |Q|, a, 1))

[0246] (|Q| - 1, a, x, a, 0)

[0247] (|Q| - 1, #, x, #, 0)

[0248] In the case of the initial state 0 and the initial memory ##aaaa##, the machine executes as follows.

[0249]

[0250]

[0251] During this execution, the instruction (8,#,x,#,0) is replaced by (8,#,y,#,1). The meta-instruction (w,a,|Q|,a,1,(|Q|-1,a,|Q|,a,1)) executes (8,a,x,a,0) and replaces it with the new instruction (8,a,9,a,1). Additionally, the simple meta-instruction (|Q|-l,a,x,a,0) temporarily adds the instructions (9,a,x,a,0), (10,a,x,a,0), and (11,a,x,a,0).

[0252] Subsequently, these new instructions are respectively replaced by (9,a,10,a,1), (10,a,11,a,1), and (11,a,12,a,l). Similarly, the simple meta-instruction (|Q|-1,#,x,#,0) adds the instruction (12,#,x,#,0), and this instruction is replaced by the instruction (12,#,n,#,1). Finally, the instructions (9,#,y,#,1), (10,#,n,#,1), (11,#,y,#,1), and (12,a,13,a,1) are added.

[0253] Furthermore, five new states 9, 10, 11, 12, and 13 are added to Q. After this calculation stops, the machine state is Q = {0,h,n,y,t,v,w,x,8,9,10,11,12,13} and the resulting ex-machine evolves to have 24 instructions. Call it Machine Instruction 1.

[0254] (0,#,8,#,l)

[0255] (y,#,h,Y,0)

[0256] (n,#,h,N,0)

[0257] (x,#,x,0)

[0258] (x,a,t,0)

[0259] (x,0,v,#,0,(|Q|-1,#,n,#,1))

[0260] (x,1,w,#,0,(|Q|-1,#,y,#,1))

[0261] (t, 0, w, a, 0, (|Q| - 1, #, n, #, 1))

[0262] (t, 1, w, a, 0, (|Q| - 1, #, y, #, 1))

[0263] (v, #, n, #, 1, (|Q| - 1, a, |Q|, a, 1))

[0264] (w, #, y, #, 1, (|Q| - 1, a, |Q|, a, 1))

[0265] (w, a, |Q|, a, 1, (|Q| - 1, a, |Q|, a, 1))

[0266] (|Q| - 1, a, x, a, 0)

[0267] (|Q| - 1, #, x, #, 0)

[0268] (8, #, y, #, 1)

[0269] (8, a, 9, a, 1)

[0270] (9, #, y, #, 1)

[0271] (9, a, 10, a, 1)

[0272] (10, #, n, #, 1)

[0273] (10, a, 11, a, 1)

[0274] (11, #, y, #, 1)

[0275] (11, a, 12, a, 1)

[0276] (12, #, n, #, 1)

[0277] (12, a, 13, a, 1)

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

[0279] The zero, first, and third 1s in the name of in its language. The second and fourth 0s indicate that the strings aa and aaaa are not in its language.

[0280] The symbol x represents all strings a n (where n ≥ 5) have not had their membership in the language determined.

[0281] Starting from state 0, the ex-machine computes that the empty string is in its language.

[0282]

[0283]

[0284] Starting from state 0, the ex-machine computes that the string a is in its language.

[0285]

[0286] Starting from state 0, it computes that the string aa is not in its language.

[0287]

[0288] Starting from state 0, it computes that the string aaa is in its language.

[0289]

[0290] Starting from state 0, it computes that the string aaaa is not in its language.

[0291]

[0292]

[0293] Note that for each of these executions, no new states are added, nor are instructions added or replaced. Thus, for all subsequent executions, the ex-machine computes that the empty string, a, and aaa are in its language. Similarly, for all subsequent executions of the strings aa and aaaa are not in

[0294] Starting from state 0, we check the execution of the ex-machine on the input memory ##aaaaaaa##.

[0295]

[0296] Overall, during this execution, the ex-machine evolved into an ex-machine executed three quantum random instructions. The first quantum random instruction (x, a, t, 0) was measured as 0, so it is shown above as (x, a, t, 0_qr, 0). The result of this 0-bit measurement added the instruction (13, #, n, #, 1), such that in all subsequent executions of the ex-machine the string a 5 is not in the language of. Similarly, the second quantum random instruction (x, a, t, 0) was measured as 1, so it is shown above as (x, a, t, l_qr, 0). The result of this 1-bit measurement added the instruction (14, #, y, #, 1), such that in all subsequent executions the string a 6 is in the language of. Finally, the third quantum random instruction (x, #, x, 0) was measured as 1, so it is shown above as (x, #, x, l_qr, 0). The result of this 1-bit measurement added the instruction (15, #, y, #, 1), such that in all subsequent executions the string a 7 is in the language of.

[0297] Finally, with the string in state 0, we examine the unique execution of the ex-machine on the input memory ##aaaaaaa##. The unique execution of

[0298]

[0299] Based on our previous examination of the ex-machine evolving into and subsequently evolving into the ex-machine 3 specifies the machine specification 3 in terms of the initial machine state and the initial machine instructions.

[1152]

[0300] Let Q = {0, h, n, y, t, v, w, x, 8, 9, 10,... m + 8, m + 9}. For 0 ≤ i ≤ m, each a i is either 0 or 1. The instructions of the ex-machine are shown as follows. If a 0= 1, then symbol b 8 = y. Otherwise, if a 0 = 0, then symbol b 8 = n. Similarly, if a1 = 1, then symbol b9 = y. Otherwise, if a 1 = 0, then symbol b 9 = n. And so on, until reaching the second to last instruction (m+8,#,b m+8 ,#,1), if a m = 1, then symbol b m+8 = y. Otherwise, if a m = 0, then symbol b m+8 = n.

[0301] (0,#,8,#,1)

[0302] (y,#,h,Y,0)

[0303] (n,#,h,N,0)

[0304] (x,#,x,0)

[0305] (x,a,t,0)

[0306] (x,0,v,#,0,(|Q|-1,#,n,#,1))

[0307] (x,1,w,#,0,(|Q|-1,#,y,#,1))

[0308] (t,0,w,a,0,(|Q|-1,#,n,#,1))

[0309] (t,1,w,a,0,(|Q|-1,#,y,#,1))

[0310] (v,#,n,#,1,(|Q|-1,a,|Q|,a,1))

[0311] (w,#,y,#,1,(|Q|-1,a,|Q|,a,1))

[0312] (w,a,|Q|,a,1,(|Q|-1,a,|Q|,a,1))

[0313] (|Q|-1,a,x,a,0)

[0314] (|Q|-1,#,x,#,0)

[0315] (8,#,b 8 ,#,1)

[0316] (8,a,9,a,1)

[0317] (9, #, b 9 , #, 1)

[0318] (9, a, 10, a, 1)

[0319] (10, #, b 10 , #, 1)

[0320] (10, a, 11, a, 1) ...

[0321] (i + 8, #, b i+8 , #, 1)

[0322] (i + 8, a, i + 9, a, 1) ...

[0323] (m + 7, #, b m+7 , #, 1)

[0324] (m + 7, a, m + 8, a, 1)

[0325] (m + 8, #, b m+8 , #, 1)

[0326] (m + 8, a, m + 9, a, 1)

[0327] The machine computes property 7.1.

[0328] Whenever i satisfies 0 ≤ i ≤ m, if a i = 1, then the string a 1 is in the language; if a i = 0, then the string ai is not in the language. Whenever n > m, it is not determined whether the string a n is in the language.

[0329] Proof. When 0 ≤ i ≤ m, the first result follows immediately from the definition of a i (which is in the language) and ex-machine 3. In the instruction (i + 8, #, b i+8 , #, 1), if α i = 1, then the state value of b i+8 is y; if α i = 0, then the state value of b i+8 is n.

[0330] Regarding the ambiguity of the string a n , when n > m, ex-machine is scanning a nExecute its last instruction (m + 8, a, m + 9, a, 1) when the m-th a in m For each a on the memory on the right side (higher memory address) up to, the ex-machine Execute the quantum random instruction (x, a, t, 0).

[0331] If the execution measurement of (x, a, t, 0) is 0, execute two meta-instructions (t, 0, w, a, 0, (|Q| - 1, #, n, #, 1)) and (w, a, |Q|, a, 1, (|Q| - 1, a, |Q|, a, 1)). If the next memory value on the right is a, execute the new standard instruction instantiated from the simple meta-instruction (|Q| - l, a, x, a, 0). If the memory address points to the last a in n Execute the new standard instruction instantiated from the simple meta-instruction (|Q| - 1, #, x, #, 0).

[0332] If the execution measurement of (x, a, t, 0) is 1, execute two meta-instructions (t, 1, w, a, 0, (|Q| - 1, #, y, #, 1)) and (w, a, |Q|, a, 1, (|Q| - 1, a, |Q|, a, 1)). If the next memory value on the right is a, execute the new standard instruction instantiated from the simple meta-instruction (|Q| - 1, a, x, a, 0). If the memory address points to the last a in n Execute the new standard instruction instantiated from the simple meta-instruction (|Q| - 1, #, x, #, 0).

[0333] In this way, for each a on the memory on the right side (higher memory address) 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 the language of.

[0334] After executing (|Q| - 1, #, x, #, 0), the memory address points to the blank symbol, so the quantum random instruction (x, #, x, 0) is executed. If measured as 0 by the quantum random source, execute the meta-instructions (x, 0, v, #, 0, (|Q| - 1, #, n, #, 1)) and (v, #, n, #, 1, (|Q| - 1, a, |Q|, a, 1)). Then the last instruction executed is (n, #, h, N, 0), which indicates that a n is not in the language of.

[0335] If the execution measurement of (x, #, x, 0) is 1, then execute the meta-instructions (x, 1, w, #, 0, (|Q| - 1, #, y, #, 1)) and (w, #, y, #, l, (|Q| - 1, a, |Q|, a, l)). Then the last instruction executed is (y, #, h, Y, 0), which indicates a n In the language of

[0336] During the execution of the instruction, for each a on the memory at the right side (higher memory address) of #a m According to the specification in ex-machine 3, the ex-machine evolves into one of which replaces m with n.

[0337] Remark 7.3. When the binary string a 0 a 1 ...a m is used as input, the ex-machine instructions (specified in ex-machine 3) can be constructed using standard machine construction.

[0338] Contrary to Lemma 7.1, the instructions of i # cannot be executed using a standard machine (when the input memory ##a satisfies i > m) because meta-instructions and quantum random instructions are required. Therefore, Remark 7.3 distinguishes the construction of the instructions of 0 a 1 ...a m ) from the execution of the instructions of i Proof. When given a finite list (a the instructions of m are constructed as follows. Starting with the comment ;;Qx_builder.lsp, the code list is expressed in a dialect of LISP called newLISP. (See www.newlisp.org). LISP is designed based on the lambda calculus developed by Alonz Church. Appendix

[33] outlines the proof that the lambda calculus is computationally equivalent to digital computer instructions (i.e., standard machine instructions).

[0339] The following 3 instructions print the ex-machine instructions listed in machine instruction 1 of

[0340] (set 'a0_al_dots_am (list 1 1 0 1 0))

[0341] (set'Qx_machine(build_Qx_machine a0_al_dots_am))

[0342] (print_xmachine Qx_machine)

[0343]

[0344]

[0345]

[0346]

[0347]

[0348] Machine Specification 7.3.

[0349] Let be defined as and the union of all ex - machines for each and for each a o ...a m in {0,1} m+1 In other words

[0350]

[0351] Theorem 7.2.

[0352] Each language L in f can be computed by the development sequence of an ex - machine

[0353] Proof. The theorem follows from ex - machine 2, ex - machine 3, and Lemma 7.1.

[0354] Machine Computation Property 7.3.

[0355] Given a function

[0356] For arbitrarily large n, the development sequence of an ex - machine computes the language L f .

[0357] Machine Computation Property 7.4.

[0358] Furthermore, for each n, all combinations of ex - machines ​Only a limited amount of memory, a finite number of states, a finite number of instructions, a finite number of executions of instructions, and only a finite amount of quantum random information measured by quantum random instructions are used.

[0359] It follows immediately from Remarks 2, Specification 7, and the specification of ex-machine 3 that for each n, there is a finite use of computational resources.

[0360] A set X is said to be countable if there is a bijection between X and N. Since the set of all Turing machines is countable, and each Turing machine recognizes only a single language, most (in terms of Cantor's hierarchy of infinities) languages L f The languages L recognized by Turing machines are uncountable. More precisely, the set of languages L f recognized by Turing machines has cardinality N 0 , while the set of all languages has cardinality N 1 .

[0361] For each non-negative integer n, define the language tree and f(i) = a i , for i such that 0 ≤ i ≤ n}. Define the corresponding subset of {0,1} N as for i such that 0 ≤ i ≤ n}. Let Ψ denote this one-to-one correspondence, where, and

[0362] Since both the random measurement property 1 and the random measurement property 2 are satisfied, each finite path f(0)f(l)...f(n) is equally likely, and there are 2 n+1 such paths. Thus, the probability of each path of length n + 1 is 2 -(n+1) . These uniform probabilities on finite strings of the same length can be extended to a Lebesgue measure μ on the probability space {0,1} N . Thus, each subset S(a 0 a 1 ...a n ) has measure 2 -(n+1) i.e., μ(S(a 0 a 1 ...a n )) = 2 -(n+1) and Via Ψ, i.e., the correspondence between each language tree and the subset S(a 0 a 1 ...a n ), n), the uniform probability measure n induces The uniform probability measure v on, where, and Theorem 7.5. For the function language L f The probability that is Turing-uncomputable has measure 1 in is 1.

[0363] Proof. Turing machines are countable. Thus, the number of Turing-computable functions is countable. Therefore, by the correspondence of Ψ, the Turing-computable language L f in has measure 0.

[0364] Furthermore, random sequences in {0, 1} N have Lebesgue measure 1 and are a proper subset of Turing-uncomputable sequences.

[0365] Machine computational property 7.6. is not a Turing machine. Each ex-machine in it is not a Turing machine.

[0366] Proof. can be developed into a Turing-uncomputable language on a set that computes probability measure 1. Additionally, can be developed into a Turing-uncomputable language on a set that computes measure 2 on a set that computes measure 2 while each Turing machine only recognizes a single language with measure 0. In fact, the measure of all Turing-computable languages is 0 in -(m+1) is 0. is 0.

[0367] These inferences are notable because the languages that ex-machines can compute reflect their computational capabilities. This means that it is feasible to utilize ex-machines for practical applications that cannot be achieved with digital computer programs.

[0368] 8 The ex-machine halting problem

[0369] In

[24] , Alan Turing proposed the halting problem for Turing machines. Is there a Turing machine D that can determine whether the execution of any given Turing machine M on a finite initial tape T will eventually halt on tape T? In the same paper

[24] , Turing proved that no Turing machine can solve its halting problem.

[0370] Next, we explain what Turing's seminal result depends on in terms of abstract computational resources. Turing's result means that there is no single Turing machine H — regardless of H's finite set of states Q and finite alphabet A — such that when this particular machine H is presented with any Turing machine M with a finite tape T and initial state q0, then H can perform a finite number of computational steps, halt, and correctly determine whether M halts with tape T and initial state q0. In terms of definability, Turing's statement of the halting problem encompasses all possible Turing machines and all possible finite tapes. This means that for every tape T and machine M, there are finite initial conditions imposed on tape T and machine M. However, since tape T and machine M cover all possibilities, the computational resources required by tape T and machine M are unrestricted. Thus, the computational resources required by H are unrestricted because its input covers all finite tapes T and machines M.

[0371] The previous paragraph provides some observations regarding Turing's halting problem because any philosophical objections to unrestricted computational resources for U(x) during its development should also raise similar philosophical objections to the assumptions in Turing's statement and his proof of the halting problem. Note that Corollary 7.4 supports our claim.

[0372] Since in and every other x-machine is not a Turing machine, the halting problem for Turing machines is naturally extended. Is there an x-machine such that for any given Turing machine M and finite initial tape T, then can sometimes compute whether the execution of M on tape T will eventually halt?

[0373] Before we can call this the halting problem for x-machines, the expression can sometimes compute whether must be defined in order to well-define the problem. A reasonable definition requires some work.

[0374] According to the Universal Turing Machine / Enumeration Theorem

[21] , there exists a Turing-computable

[0375] enumeration Similar to x-machines, for each machine M, the set {Each of M's states as an initial state} can be realized as of {0,..., n - 1}. Since ε(n) is an ordered pair, "the Turing machine ε(n)" refers to the first coordinate of ε(n). Similarly, "the initial state ε(n)" refers to the second coordinate of ε(n).

[0376] Recall that the halting problem for Turing machines is equivalent to the halting problem for the blank tape. (See pages 150 - 151 of

[15] .). For our discussion, the blank tape halting problem is transformed into: For each Turing machine ε(n), when ε(n) starts its execution with a blank initial tape and initial state ε(n), does the Turing machine ε(n) halt?

[0377] Lemma 7.1 implies that the same initial x - machine can develop into two different x - machines; furthermore, these two x - machines will never compute the same language no matter what kind of descendants they develop into. For example, and will never compute the same language in. Thus, sometimes it means that for each n, there exists such a development: to and then to and so on until where, for each i where 0 ≤ i ≤ n, then, correctly computes whether the Turing machine ε(n) - executing on the initial blank tape with initial state ε(n) - halts.

[0378] In the previous sentence, the word "computes" means halts after a finite number of instructions have been executed, and the halting output has been written on its tape indicating whether the machine ε(n) halts. For example, if the input tape is ##a i #, then the enumeration machine Mε writes the representation of ε(i) on the tape, and then (where m ≥ i) halts, where #Y# is written to the right of the representation of the machine ε(i). Alternatively, (where m ≥ i) halts, where,#N# is written to the right of the representation of the machine ε(i). The word "Correctly" means that the x - machine halts with #Y# written on the tape (if the machine ε(i) halts), and the x - machine halts with #N# written on the tape (if the machine ε(i) does not halt).

[0379] Next, our goal is to transform the x - machine halting problem into a form so that the results of the previous section can be applied. Choose the alphabet to be A = {#, 0, 1, a, A, B, M, N, S, X, Y}. As mentioned before, for each Turing machine, it is helpful to identify the set of machine states Q as a finite subset of. Let M ε be the Turing machine that computes the Turing - computable enumeration as where the tape ##a n # represents the natural number n. Each εa (n) is an ordered pair, where the first coordinate is a Turing machine and the second coordinate is a a (n) is the initial state of one of the states of Mε. (Chapter 7 of

[15] provides clear details of encoding quintuples using a particular universal Turing machine. The letter A is chosen so that it is compatible with this encoding. A careful study of Chapter 7 provides how the instructions for Mε can be specified to implement ε a clear path).

[0380] Remark 8.1. For each n€N, where the blank initial strip and the initial state ε a (n), then the Turing machine ε a (n) To stop or not to stop.

[0381] Proof. The behavior of a Turing machine computation is well-defined. For each n, there are only two possibilities.

[0382] For our specific example ε a , for the stop function hε a :definition As follows. For each n, the set hε a (n) = 1 whenever there is a blank initial strip and an initial state ε a (n) Turing machine ε a (n) Stop. Otherwise, the set hε a (n) = 0, if there is a blank initial strip and an initial state ε a (n) Turing machine ε a (n) does not stop. Remark 8.1 implies that the function hε a (n) is well defined. By stopping the function hε a (n) and Definition 7.1, define the stopping language Lhε a Theorem 8.1. X-machines With computation stopping language Lhε a The development path is

[0383] Proof. Theorem 8.1 follows from the previous discussion, including the stopping function hε a (n) and the stop language Lhε a Definition of and Theorem 7.2.

[0384] 8.1 Some Observations Based on Theorem 8.1

[0385] Theorem 8.1 provides a positive answer to the x-machine halting problem, but in practice, from a probabilistic point of view, The specific implementation of will not develop to calculate Lh(ε a ).For example, The specific execution will develop into with a probability of 2 -128 , such that correctly calculates whether each string λ, a, a 2 ...a 127 is a member of Lh(ε a ) or is not a member of Lh(ε a ).

[0386] Furthermore, Theorem 8.1 does not provide a general method to test (prove) without error develops into some new machine satisfies (for each 0 ≤ i ≤ m). We also know that any general test method applicable to all natural numbers m requires at least an ex-machine, because any general test method cannot be implemented by a standard machine. Otherwise, if such a test method could be executed by a standard machine, then this test machine could be used to solve Turing's halting problem; since Turing proved that a standard machine (digital computer) cannot solve the halting problem, this is logically impossible. This unsolvability has practical implications for program correctness in software and circuit verification in hardware.

[0387] The existence of the path indicates that it is logically possible for such a development to occur, because in principle, it can develop into computing any language L in f . In other words, Figure 3 each downward infinite path in the infinite binary tree of

[0388] In a sense, Theorem 8.1 has a similar result in pure mathematics. Brouwer fixed point

[0389] This theorem guarantees that a continuous mapping from n items to n items has at least one fixed point and illustrates the role of algebraic topology. However, the early proofs were indirect and did not provide a construction method to determine the fixed point. Similarly, Theorem 8.1 guarantees the existence of a development path, but the proof does not provide a general method to test the development up to stage m without error and then satisfies (for each 0 ≤ i ≤ m). This is why the self-modifying method integrated with randomness is used.

[0390] 9 correspondence

[0391] In the previous section titled "Ex-machine halting problem", due to the meta-instructions of the ex-machine and the random instructions using self-modification and randomness, this machine is not restricted by the halting problem. This ability of the ex-machine has some extremely practical applications. In the prior art, due to Turing's halting problem, standard machines or digital computers cannot solve the program correctness of standard programs.

[0392] Program correctness is very important, not only because of the problem of malware

[28] infecting mission-critical software. However, program correctness is also crucial for any hardware / software system (whether infected with malware or not) running air traffic control, power grids, the Internet, GPS

[16] , autonomous driving networks, and so on.

[0393] This section shows how to transform any standard program into a geometric problem; then, a novel self-modifying program implemented through the self-modifying ability of the ex-machine and / or traditional machine learning methods can be used to solve the geometric problem. For example, detecting an infinite loop in a standard program is a special case of the halting problem, and detecting an infinite loop is a subset of program correctness.

[0394] With this in mind, the correspondence can transform any standard digital computer program - no matter how large - into a geometric problem in the complex plane C. Consider the standard machine M. Define the transformation such that each standard instruction in M is mapped to an affine function in the complex plane C. Let the machine state Q = {q 1 ,...,q m}. Let the alphabet A = {a 1 ,...,a n}, where a 1 is the blank symbol #. The halting state h is not in Q. The function η: Q×A→Q∪{h}×A×{-1,+1} represents the standard machine instructions, where η(q, a) = (r, b, x) corresponds to the standard instruction (q,a,r,b,x). Let B = |A|+|Q|+1. Define the symbol value function:

[0395]

[0396] T k is the memory value in the k-th memory address. The machine configuration (q,k,T) is in . The machine configuration (q,k,T) is mapped to the complex number whose real and imaginary parts are reasonable because the bounded finite memory condition of the standard machine (i.e., finite memory) implies that only a finite number of memory cells contain non-empty values.

[0397] Remark 9.1. If two machine configurations \((q, l, T)\) and \((r, k, S)\) are not equivalent, then That is to say, it is one-to-one within the equivalent class of machine configurations.

[0398] Proof. By transforming our memory representation \(T\) via \(R(j)=T(j + l - k)\), W.L.O.G. we assume \(l = k\). Thus, we compare \((q, k, T)\) and \((r, k, S)\). Assume then the real parts must be equal. This implies that, for all \(j\geq - 1\), \(T\) k+j+1 \(=S\) k+j+1 Therefore, \(T\) j \(=S\) j for all \(j\geq k\).

[0399] For the imaginary parts, \(|Bv(q)-Bv(r)|\geq B\) whenever \(q\neq r\). Moreover, Similarly, Therefore, since \(B > |A|\), this implies \(q = r\) and \(T\) k-j-1 \(=S\) k-j-1 for all \(j\geq0\). This means \(T\) j \(=S\) j for all \(j\leq k - 1\). Thus, \((q, k, T)=(r, k, S)\).

[0400] The next part defines a one-to-one mapping from a standard digital computer program \(\eta\) to a finite set of affine functions whose domain is a bounded subset of \(\mathbb{C}\). According to Figure 7A , one can obtain Equation 1 for the real part and Equation 2 for the imaginary part for machine configuration 710.

[0401]

[0402] Right affine mapping

[0403] Before executing the instruction \((q, T\) k , \(r, b, + 1)\), the machine is in configuration 710, as Figure 7A shown. In this computational step (execution step), the machine state \(q\) moves to state \(r\). The memory value \(b\) replaces \(T\) at memory address \(k\), k and the storage head moves to memory address \(k + 1\). The corresponding right affine function has the form \(f(x+yi)=f\) 1 (x)+f 2 (y)i, where \(f\) 1 (x)=|A|x + m and Figure 7Bshows the machine configuration 725 after executing the instruction 720(q,T k ,r,b,+1). The machine configuration 725 is used to calculate the value of m in f 1 (x) and the value of n in f 2 (x).

[0404] According to Equation 1, Therefore, Equation 3 defines the real part of the affine mapping of the instruction (q,T k ,r,b,+l).

[0405] f 1 (x) = |A|x+(|A|-1)v(T k+1 )-|A| 2 v(T) k ) (3)

[0406] According to Equation 2, Therefore, n Equation 4 defines the imaginary part of the right - hand affine mapping corresponding to the instruction 720, where (q,T k ,r,b,+1) is shown in Figure 7B .

[0407]

[0408] Left - hand affine mapping

[0409] For mapping the instruction (q,T k ,r,b,-1) to the left - hand affine function g(x + yi)=g 1 (x)+g 2 (y)i, we calculate the formula, where and g 2 (y)=|A|y + n. Figure 7C shows the machine configuration 735 after executing the instruction 730(q,Tk,r,b,-1). The machine configuration 735 is used to calculate the value of m in g 1 (x) and the value of n in g 2 (y).

[0410] First, before executing (q,T k ,r,b,-1), Equation 1 holds. Moreover, Therefore,

[0411]

[0412] For the imaginary part, before executing the instruction (q, T k , r, b, -1), Equation 2 holds. Multiply by Finally, Therefore, n = Bv(r) - |A|Bv(q) - |A|v(T k-1 ).

[0413] g 2 (y) = |A|y + Bv(r) - |A|Bv(q) - |A|v(T k-1 ) (6)

[0414] Define the stopping attractor and B|A| ≤ y ≤ (B + 1)|A|}. The set of all points in C corresponding to the stopping configuration (h, k, T) is called the stopping point.

[0415] Remark 9.2 and 9.3 establish that the stopping point is a subset of. Define the stopping map such that on . This means that every point in the stopping attractor is a fixed point.

[0416] Remark 9.2. Every stopping point satisfies B|A| ≤ y ≤ (B + 1)|A|.

[0417] Proof. Let x h + y h i be the stopping point. Then Therefore, yh ≥ B|A| since the infinite sum of all blank tapes is 0. If A = {#}, then the stopping behavior is trivial, so we assume |A| ≥ 2 in the next part. If v(T k-j-1 ) = |A| - 1 for all j ≥ 0, then the sum of this geometric series is

[0418] Remark 9.3. Every stopping point x h + y h i in satisfies 0 ≤ x h ≤ |A| 2 .

[0419] Proof. |x| ≥ 0 since each term ≥ 0. Analyze the equation

[0420] The domain of each affine function is a unique unit square and n ≤ y ≤ n + 1}, where m and n are integers. Therefore, Convert Turing's halting problem into the following dynamic system problem, which is of the type of geometric problems. If the machine configuration (q,k,T) halts after n computational steps, then the orbit of exits one of the unit squares at the n-th iteration and enters the halting attractor In other words, we say that the execution of the computer program η with the initial configuration (q,k,T) enters the halting attractor after a finite number of execution steps

[0421] If the machine configuration (r,j,S) is permanent (i.e., never halts), then the orbit of remains forever within these finite number of unit squares and never enters the halting attractor

[0422] For a particular standard machine, the set X is equal to the union of all the closed unit squares induced by and the halting attractor Closed means that the unit square contains its boundary. Since there are a finite number of unit squares and is a compact set, there exists a compact (i.e., closed and bounded) set D and a connected path such that D contains the closed unit squares and the halting attractor Define as the function extension of a finite number of left and right affine functions f and g, specified by equations 3, 4, 5, 6, and define it as the extension of the halting function .

[0423] 10 Program correctness based on entering the halting attractor

[0424] One of the main inventions provided in this section is that the correctness of a computer program with an initial configuration can be calculated based on whether the execution of the program enters the halting attractor of the program in the complex plane C In other words, the new computational method implemented in hardware and software for solving deep theoretical mathematical problems has many practical software and hardware applications and inventions that are currently considered unsolvable by the prior art.

[0425] In an embodiment, the ex-machine receives as input the standard instruction 110 ( Figure 1A ) of the standard machine M (also referred to as a computer program or a standard computer program), which is stored in the ex-machine in the input system 242 Figure 2B )。The ex-machine also receives as input the initial configuration of a standard computer program: the initial configuration includes the initial machine state q of the computer program M and the initial memory content T.

[0426] ex-machine The ex-machine X executes the machine instruction 100 using the processor system 252 and calculates the left and right affine mappings of M according to equations 3, 4, 5, and 6. Then, the ex-machine X stores the left and right affine mappings of M (i.e., the calculation results of equations 3, 4, 5, and 6) in the storage system 246.

[0427] In another embodiment, the ex-machine receives as input a standard instruction 110 Figure 1A ) as input expressed in the C programming language

[12] . In an embodiment, the input to X is a list of standard instructions 110, which is expressed as C code. Three tests are provided for the function FFMul(unsigned char a, unsigned char b). During the execution of the computer program, if one of the three tests has an error, 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 the function FFMul(unsigned char a, unsigned char b) fails, the execution of the program never enters its stop attractor. If the execution of this computer program successfully verifies all 3 tests, the execution of the program exits the function main() and successfully enters the stop attractor.

[0428]

[0429]

[0430]

[0431] In a previous C list, the following includes the initial configuration of this C program: the initial value of the constant NUM_TESTS is set to 3; in the memory system 246, the initial values of the array variable a[NUM_TESTS] are set to 59, 117, and 197; in the storage system 246, the initial values of the variable b[NUM_TESTS] are set to 237, 88, 84; in the memory system 246, the initial values of the variable correct.result[NUM_TESTS] are set to 243, 208, 17; in the memory system 246, the initial value of the variable test.result is set to 0.

[0432] In another embodiment, the ex-machine receives as input standard instruction 110( Figure 1A ) expressed as input in the Python programming language.

[0433] For example, the input to can be the following list of standard instructions, expressed as Python code.

[0434]

[0435]

[0436]

[0437] In another embodiment, the ex-machine receives as input standard instruction 110

[0438] ( Figure 1A ) expressed in the hardware data flow language VHDL

[25] .

[0439] Machine embodiment 4. Correctness of Goldbach's conjecture

[0440] The purpose of the following program is to prove that Goldbach's conjecture is correct. Goldbach's conjecture states that every even number greater than or equal to 4 is the sum of two prime numbers. 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 a stop attractor; that is, if its execution remains forever in the while(g == true) loop and never reaches a stop instruction. As previously mentioned, the code in the Goldbach machine can be transformed into a finite set of affine mappings in the complex plane C.

[0441]

[0442] Machine Embodiment 5. Correctness of Hardware Circuit Design

[0443] We describe another embodiment of a program that can check for correctness. In hardware design, there are a finite number of timing constraints to determine whether there are race conditions in a hardware circuit. Race conditions are generally considered to be program errors or hardware design errors. In some cases, a computer program can be specified to check each of these timing constraints; if one of the timing constraints is violated, the computer program can enter a trivial infinite loop, such as

[0444]

[0445] If none of the timing constraints are violated, the program enters a stopped state, indicating that the computer program that tests the timing constraints is correct. In this case, the computer program entering the stop attractor indicates that the computer program is correct, and thus there are no race conditions in the circuit design.

[0446] In this case, contrary to the Goldbach machine, the meaning of the computer program execution that enters the stop attractor being the opposite of the program is incorrect, while the program is correct.

[0447] Machine Embodiment 4 and Machine Embodiment 5 teach us the following: For some computer programs, entering the stop attractor means the program has an error; for other computer programs, entering the stop attractor means the program is correct. The meaning of a computer program entering the stop attractor depends on the specific computer program and must be understood on a case-by-case basis.

[0448] 11 Machine Learning with Self-Modification and Randomness

[0449] In this section, we describe an invention that uses self-modification and randomness to advance machine learning programs. In the prior art, machine learning programs are implemented using algorithms that are computationally equivalent to Turing machine algorithms [5, 14, 15, 24]. As shown in Sections 7 and 8, machine computing that adds randomness and self-modification capabilities to standard digital computer instructions has greater computational power compared to standard digital computers. This capability enables more advanced machine learning programs, where, in some embodiments, meta-instructions 120 and random instructions 140 improve the machine learning program.

[0450] In the prior art, certain machine learning algorithms are based on a multi-layer method of constructing functions using a weighted sum of sigmoid functions ( Figure 8A ) or some other non-linear function fed into the next layer. For example, see Figure 8C , where each node has a sigmoid function. In our embodiment, arctan(x) is our prototype sigmoid function 810, as Figure 8A shown. First, it is important to observe that the prior art (not understanding that computing can compute Turing-incomputable languages) only uses Turing machine algorithms for its machine learning methods. This may be at least part of the reason why machine learning algorithms work well with a certain amount of training and then suddenly hit a wall in terms of the tasks that the machine learning algorithms can perform.

[0451] When the non-linear function is a sigmoid function 810, we call it a neural network, as Figure 8C shown. In the prior art, the learning algorithm for multi-layer methods is of the type of gradient descent: the weights in each weighted sum of the neural network are adjusted according to an error function, which is calculated based on the degree to which the neural network can classify or predict an embodiment on a training data set.

[0452] The gradient descent is calculated with respect to the error function calculated 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 method (such as backpropagation

[11] ) is a Turing machine algorithm.

[0453] In our embodiment, our almost step function will generally be a piecewise linear approximation of the form g a，b，c (x) = exP(-b(x - a) c ) where b and c are parameters that adjust the width of the center of the step function that maps the translation of the step function for an interval of 1 to a. In Figure 8B , the center of the almost step function is located at x = 0 and 6 = 2 and c = 20. If we choose c = b 2 , then we can form 10 different almost step functions, where the b values are in such that rare events can be localized or almost all events of a certain type can be ignored. For an embodiment with greater flexibility, where b and c are independent of each other, we can choose a, b, and c to vary randomly and be executed with random instructions. When we take the average value of the slopes of the approximate vertices, the derivative of the piecewise linear approximation of g a，b，c (x) = exp(-b(x - a) c ) is everywhere visible. Because of the following theorem from real analysis, we start with an almost step function. For any Lebesgue measurable function and for any ∈ > 0, there exists a finite sum of step functions such that the on the set of Lebesgue measure is greater than 1 - ∈.

[0454] In some embodiments, our machine learning program (including standard instructions, random instructions, and

[0455] meta-instructions) begins with the gradient descent method, which can be used on networks of almost step functions and sigmoid functions. Meta-instructions can be used to modify our initial gradient descent program and also how gradient descent understands the differential geometry of our network of non-linear functions. In some embodiments, the self-modification of the initial gradient descent will depend on differential forms, curvature tensors, and the curvature of saddle points, such that the standard instructions 940, meta-instructions 930, and random instructions 920 can reason about the execution of the machine learning program 950 based on its training dataset. Based on reasoning about geometric concepts that depend on differential forms, curvature tensors, and saddle point curvature, the meta-instructions 930 and random instructions 920 assist in the self-modification of the machine learning program.

[0456] The way the machine learning program develops sometimes depends on the characteristics of the specific dataset on which the training is performed.

[0457] In some embodiments, we use an almost step function 820, as shown in our Figure 8B which is a piecewise linear approximation of g a，b，c (x) = exp(-b(x - a)c). In some embodiments, we use the almost step function 820 and the sigmoid function 810 in our machine learning program, or a composite function consisting of a weighted sum of approximate step functions and sigmoid functions at the nodes. In an embodiment, the construction of any composed function executes standard instructions 110, random instructions, and meta-instructions, so there is no algorithmic constraint on how these composed functions are constructed. In an embodiment, we refer to it as a network 850 of non-linear functions, thus differentiating our non-algorithmic approach to constructing function combinations from the prior art that uses neural networks 830 consisting only of sigmoid functions or a type of non-linear function network.

[0458] In some embodiments, two subscripts denote the layer and reference of a specific non-linear function 850 at that position. In an embodiment, we use n different non-linear functions at each node of the network and name them In Figure 8C , n = 1, where arctan(x). In Figure 8D , n = 2, where arctan(x) and

[0459] The use of a multi-layer algorithm for machine learning is based on a weighted sigmoid function 810, or some other non-linear function that looks like a hockey stick composed of two linear segments. In an implementation of a machine learning program 950, it uses standard instructions 940, random instructions 920, and meta-instructions 930, as Figure 8E shown, each function g i，j (x)850 is selected from and is located at a node, which is in the j-th column of layer i. Let n i be the number of nodes in layer i. In an implementation, the weighted linear sum of the non-linear function g i+1,l (x) from layer i to the next layer i + 1 is as Figure 8E shown.

[0460] 12 Non-deterministic Execution Machine

[0461] Before formally describing it in the machine specification 12.1, first give a brief and intuitive overview of the non-deterministic execution machine. Our non-deterministic execution machine should not be confused with the non-deterministic Turing machine described on pages 30 and 31 of

[12] .

[0462] Part of the motivation for us to adopt this approach is that the program 5 is easier to analyze and implement. Some implementations of the program 5 can be achieved using the randomness generator 548 in Figure 5A . In some implementations, the randomness generator 542 in Figure 5A as well as the photon sources shown in Figure 6A , Figure 6B and Figure 6C can help achieve the program 5 with the random measurement 130 shown in Figure 1A . In addition, our non-deterministic execution machine can be simulated with an ex-machine.

[0463] In a standard digital computer, a computer program can be specified as a function; starting from the 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 be executed next, otherwise the Turing machine stops at this machine configuration.

[0464] In an implementation of the non-deterministic execution machine of the present invention, the program is a relation rather than a function. From a specific machine configuration, there is ambiguity about the next instruction I to be executed. This is a computational advantage when the opponent does not know the purpose of the program . Using Figure 1ARandom measurements 130 in measure randomness to assist in selecting the next instruction to execute. In some embodiments, non-deterministic hardware as shown in 5A or 5B is used to measure quantum randomness. In another embodiment, non-deterministic hardware as shown in 5C is used to measure quantum randomness, where the non-deterministic rotation - 1 source is obtained by measuring the spin of an electron.

[0465] Part of our non-deterministic execution machine specification is that every possible instruction has a possibility of being executed. Use Figure 1A 130 in to measure some quantum randomness, and select the next instruction to execute based on this quantum measurement and the possibility of each instruction. In some embodiments, hardware designed according to the Figure 5C protocol in is used to measure quantum randomness.

[0466] Before providing the machine specification, check some symbol definitions. The symbol N+ is the set of positive integers. Recall that Q represents rational numbers. [0,1] is the closed interval of real numbers x such that 0 ≤ x ≤ 1. The expression means that the element x is not a member of X. For example, and The symbol n represents the intersection. Note that and

[0467] Machine specification 12.1. Non-deterministic execution machine

[0468] The non-deterministic machine N is defined as follows:

[0469] · Q is a finite set of states.

[0470] · F is the set of final states and of

[0471] · When the machine execution starts, the machine is in the initial state qo and qo ∈ Q.

[0472] · A is a finite set of memory values read from and written to the memory.

[0473] · # is a special memory value, called the blank memory value located in A.

[0474] · The memory T of the machine is represented as a function T: The memory value stored in the k-th memory cell is T(k).

[0475] · I is the next instruction relation, which is a subset of Q x A x Q x A x {—1,0,+1}. is used as a non-deterministic program, where non-determinism generates

[0476] How an instruction is selected from before it is executed. Each instruction I in the set specifies how the machine N executes a computational step. When the machine N is in state q and scanning the memory value a = T(k) at the memory cell (address) k, an instruction is selected nondeterministically (such that the first two coordinates are q and a respectively). If the selected instruction is I = (q, a, r, β, y), then the instruction I is executed as follows:

[0477] The machine N changes from machine state q to machine state r.

[0478] The machine N replaces the memory value a with the memory value β, such that T(k) = β. The rest of the memory remains unchanged.

[0479] If y = -1, then the machine N starts scanning one memory cell down in the memory, and then scans the memory value T(k - 1), which is stored at the memory address k - 1.

[0480] If y = +1, then the machine N starts scanning one memory cell up in the memory, and then scans the memory value T(k + 1), which is stored at the memory address k + 1.

[0481] If y = 0, then the machine N continues to scan the same memory cell, and then scans the memory value T(k) = β, which is stored at the memory address k.

[0482] · To ensure that N is a physically realizable machine, before the machine N starts execution, there exists M > 0 such that the memory contains only blank symbols (i.e., T(k) = #) at all memory addresses with |k| > M.

[0483] addresses.

[0484] · is a finite set of rational numbers contained in [0, 1] such that where, is the number of

[0485] instructions in

[0486] · is a bijective function. Let I be an instruction in . The purpose of v(I) is to help determine the probability of nondeterministically selecting the instruction I as the next

[0487] instruction to be executed.

[0488] The nondeterministic machine 12.1 can be used to execute two different instances of a program with different sequences of machine instructions 100, asFigure 1A as shown

[0489] Machine Specification 12.2. Machine Configuration and Effective Computational Steps

[0490] Machine Configuration M i is a triple (q, k, T i ), where q is the machine state, k is an integer which is the currently scanned memory address, and T i represents the memory. Considering the machine configuration in accordance with Machine Specification 12.1, then is an effective computational step if in the instruction I = (q, a, r, β, y) and the memories Ti and Ti+1 satisfy the following 4 conditions:

[0491] 1. v(I) > 0.

[0492] 2. T i (k)) = α.

[0493] 3. T i+1 (k) = β and T i+1 (j) = T i (j) for all j ≠ k.

[0494] 4. l = k + y.

[0495] The symbol N + is the set of positive integers. Recall that Q represents the set of rational numbers. [0, 1] is the closed interval of real numbers x such that 0 ≤ x ≤ 1. The expression means that the element x is not a member of X. For example and The symbol ∩ represents the intersection. Note that and

[0496] The purpose of Machine Program 4 is to describe how a non-deterministic machine selects machine instructions from the set of machine instructions 6700 as Figure 7B shown. This non-deterministic selection of the next instruction is based on the machine specification (i.e., the function) and one or more quantum random measurements, which are performed by the random instruction 6740. In our program, the lines starting with ;; are comments. Program 4 can be implemented as a computational system( Figure 2B ) which has an input system 242, an output system 240, a storage system 246, a random system 248, a self-modifiable system 250, and a processor system 252 with standard instructions 110, meta-instructions 120, and random instruction 6740, as Figure 1AAs shown in FIG. 1A, combining program 4 and recognizing that other parts of the machine specification 12.1 are included in standard instructions, meta-instructions, and random instructions, non-deterministic, self-modifiable (e.g., ex-machine) computations can perform non-deterministic execution on the non-deterministic execution machine in the machine specification 12.1.

[0497] Machine specification 4.

[0498] ;; The instructions in are indexed as {J 1 , J 2 ,..., J m} where

[0499]

[0500] Select the instruction Jk such that x lies in the interval L k in

[0501] In some embodiments, the machine instructions (program) 5 can be implemented with standard instructions 110, meta-instructions 120, and random instructions 140, as Figure 1A shown. The random instruction 140 performs a random measurement 130 during execution. In some embodiments, the quantum random measurement 130 is measured with a rotation-1 source (e.g., an electron), followed by an S z separator and an S x separator, as Figure 5C shown. In other embodiments, a randomness generator 552 is utilized to measure the random measurement 130, as Figure 5B shown. In some embodiments, the source of the quantum event is a photon, as Figure 6A , Figure 6B and Figure 6C shown.

[0502] In some embodiments, non-deterministically selected machine instructions can be represented in C programming language syntax. In some embodiments, certain instructions that are non-deterministically selected for execution have C syntax, such as x = l; or z = x * y;. In some embodiments, one of the selected instructions can be a loop with a machine instruction body, such as:

[0503]

[0504]

[0505] or a function such as

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

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

[0508]

[0509] In other embodiments, machine instructions may have programming language syntax such as JAVA, Go Haskell, C++, RISC machine instructions, JAVA virtual machine, Ruby, LISP, etc., or hardware languages such as VHDL.

[0510] Machine specification 5.

[0511]

[0512]

[0513] In machine instruction (program) 5, the ex-machine implementing the pseudocode executes a specific non-deterministic machine a finite number of times, and if the final state is reached, the program will increase the corresponding final state score. After calculating the final state score, make it converge within the reliability interval (0, ∈), and then, the execution of the ex-machine is completed and the ex-machine stops.

[0514] Machine specification 6.

[0515]

[0516]

[0517] Machine specification 6 is useful for executing a computational program such that each instance of the program can execute different instruction sequences in a different order. This unpredictability of instruction execution makes it difficult for an adversary to understand the computation. Machine specification 6 can be executed with a finite sequence of standard instructions, meta-instructions, and random instructions, as Figure 1A shown.

[0518] In the following analysis, estimate the likelihood of finding the largest program (machine instruction) 5.

[0519] Machine computational property 12.1. For each x, let v x = v(I x ). Consider an acceptable computational path such that the machine configuration M N is in the final state q f and is the largest. When n < N and at least rp when n ≥ N, the expected number of times the inner loop in program 6 executes the acceptable path is 0.

[0520] Proof. When n < N, the inner loop cannot execute the path Therefore, the expected number of times is 0. When N = N, each random sample selection instruction I JI independence and the fact that it is an acceptable path implies that the probability of executing this computational path is When n > N, the probability of executing this path is still p, because if the final state in M n is reached, there is an inner loop.

[0521] References

[0522] [1] John Bell. On the Einstein-Podolsky-Rosen Paradox. Physics. 1, 1964, pp. 195 - 200.

[0523] [2] Neil Bohr. Can Quantum-Mechanical Description of Physical Reality Be Considered Complete? Physical Review. 48, October 15, 1935, pp. 696 - 702

[0524] [3] Louis de Broglie. Recherches sur la théorie des quanta. Doctoral thesis. Paris, 1924.

[0525] [4] A.A. Abbott, C.S. Calude, J. Conder and K. Svozil. Strong Kochen-Specker Theorem and Uncomputable Quantum Randomness. Physics. Rev. A 86, 062109, 2012, pp. 1 - 11

[0526] [5] Martin Davis. Computability and Unsolvability. Dover Publications, New York, 1982.

[0527] [6] David Deutsch. Quantum Theory, the Church-Turing Principle and the Universal Quantum Computer. Proc. London Math. Soc. Ser. A. 400., No. 1818, 1985, - 117 pp.

[0528] [7] Antony Eagle. Randomness is Unpredictable. British Journal for the Philosophy of Science. 56, 2005, pp. 749 - 790

[0529] [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

[0530] [9] William Feller. An Introduction to Probability Theory and Its Applications, Volume 1, Third Edition. John Wiley & Sons, New York, 1968, pp. 202 - 211.

[0531]

[10] Michael R. Garey and David S. Johnson. Computers and Intractability: A Guide to the Theory of NP - Completeness. W. H. Freeman, 1979.

[0532]

[11] John Hertz, Anders Krogh and Richard G. Palmer. Introduction to the Theory of Neural Computation. Addison - Wesley Publishing Company. Redwood City, California, 1991, pp. 115 - 121.

[0533]

[12] Brian Kernighan and Dennis Ritchie. The C Programming Language. Second Edition, Prentice Hall, 1988.

[0534]

[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. 59 - 87.

[0535]

[14] Harry R. Lewis and Christos H. Papadimitriou. Elements of the Theory of Computation. Prentice - Hall, 1981.

[0536]

[15] Marvin Minsky. Computation: Finite and Infinite Machines (1st Edition). Englewood Cliffs, New Jersey. Prentice - Hall, Inc., 1967.

[0537]

[16] Pratap Misra and Per Enge. Global Positioning System: Signals, Measurements, and Performance. Revised Second Edition, Ganga - Jamuna Press, 2011.

[0538]

[17] David A. Patterson and John L. Hennessy. Computer Architecture: A Quantitative Approach. Fifth Edition, Morgan Kaufmann, 2011.

[0539]

[18] H. L. Royden. Real Analysis. Prentice - Hall Inc., 1988.

[0540]

[19] Alfred A. Schmitt. The State Complexity of Turing Machines. Information and Control. 17, 1970, pp. 217 - 225.

[0541]

[20] Claude Shannon. Communication Theory of Secrecy Systems, netlab.cs.edu / wiki / files / shannonl949.pdf. 1949.

[0542]

[21] Hartley Rogers, Jr. Theory of Recursive Functions and Effective Computability. MIT Press, 1987.

[0543]

[22] Andre Stefanov, Nicolas Gisin, Olivier Guinnard, Laurent Guinnard and Hugo Zbinden. Optical Quantum Random Number Generators. Journal of Modern Optics. 1362 - 3044, 47, 4, 2000, pp. 595 - 598. http: / / arxiv.org / pdf / quantph / 9907006

[0544]

[23] H. E. Sturgis, and J. C. Shepherdson. Computability of Recursive Functions. J. Assoc. Comput. Mach. 10, 1963, pp. 217 - 255.

[0545]

[24] Alan M. Turing. On Computable Numbers, with an Application to the Entscheidungsproblem. Proceedings of the London Mathematical Society. Series 2 42 (Parts 3 and 4), 230 - 265 (1936). Correction, ibid. 43, 1937, pp. 544 - 546.

[0546]

[25] VHSIC Hardware Description Language. 2019. https: / / en.m.wikipedia.org / wiki / VHDL

[0547]

[26] M. Wahl, M. Leifgen, M. Berlin, T. Rohlickel, Hans - Jurgen Rahn, and O. Benson. Ultrafast Quantum Random Number Generator with Provably Bounded Output Bias Based on Photon Arrival Time Measurements. Applied Physics Letters. 98, 171105, 2011.

[0548]

[27] Jie Yang, Jinlu Liu, Qi Su, Zhengyu Li, Fan Fan, Bingjie Xu, and Hong Guo. 5.4 Gbps Real-Time Quantum Random Number Generator with Compact Implementation. Optics Express. 24(24), 2016, pp. 27475-27481.

[0549]

[28] D. Zamboni (ed.). Proceedings of the 5th International Conference on Detection of Intrusions and Malware and Vulnerability Assessment LNCS. Springer. July 2008.

Claims

1. A machine - implemented method for verifying program correctness, comprising: The machine has a processor system (252), a storage system (246), and an input system (242); The machine receives a computer program (110, 720, 730) and an initial configuration (710) of the program as inputs; The machine maps the computer program (110, 720, 730) to a finite set of affine mappings (740, 760); The machine calculates that the execution of the computer program (110, 720, 730) with its initial configuration (710) enters a stop attractor (750, 770) of the program after a finite number of execution steps; wherein, entering the stop attractor (750, 770) verifies the correctness of the computer program; wherein, the machine for verifying program correctness executes with a finite number of standard instructions (110), meta - instructions (120), and random instructions (140); wherein, the affine mapping (740, 760) is an affine function that maps standard instructions to the complex plane to convert any standard digital computer program into a geometric problem in the complex plane.

2. The machine - implemented method according to claim 1, wherein, The standard instructions are executed sequentially.

3. The machine - implemented method according to claim 2, wherein, The execution of the random instruction (140) measures one or more quantum events (170).

4. A machine - implemented method for verifying program correctness, comprising: The machine has a processor system (252), a storage system (246), and an input system (242); The machine receives a computer program (110, 720, 730) and an initial configuration (710) of the program as inputs; The machine maps the computer program to a finite set of affine mappings (740, 760); The machine calculates that the execution of the computer program (110, 720, 730) with its initial configuration never enters a stop attractor (750, 770) of the program; wherein, never entering the stop attractor (750, 770) verifies the correctness of the computer program; wherein, the machine for verifying program correctness executes with a finite number of standard instructions (110), meta - instructions (120), and random instructions (140); wherein, the affine mapping (740, 760) is an affine function that maps standard instructions to the complex plane to convert any standard digital computer program into a geometric problem in the complex plane.

5. The machine - implemented method according to claim 4, wherein, The standard instructions are executed sequentially.

6. The machine - implemented method according to claim 5, wherein, The random instruction (140) is executed by performing a random measurement (130) on a quantum event (170).

7. A system for performing calculations, comprising: The system includes a processor system (252), a storage system (246), an input system (242), and an output system (240); A processor system (252) that executes machine instructions (100) includes standard instructions (110), random instructions (140), and meta-instructions (120), and the processor system (252) executes an initial machine learning program; The random instructions perform random measurements (130) when executed; A storage system (246) stores the results of the random measurements (130); And a self-modifying system (250) that, when executing at least one meta-instruction, modifies its instructions; Wherein, the standard instructions are executed sequentially; Wherein, by using an affine function that maps the standard instructions (110) to the complex plane, any standard digital computer program is converted into a geometric problem in the complex plane.

8. The system according to claim 7, Wherein, When executing the random instructions, the random measurements (130) measure one or more quantum events (170).

9. The system according to claim 7 or 8, Comprising: A storage system (246) that stores machine learning instructions (900); A self-modifying system (250) that changes the machine learning program (950) by executing one or more meta-instructions (930), And a random system (248) that executes one or more random instructions (920); Wherein, the machine learning program (950) evolves continuously during its execution.

10. The system according to claim 9, Comprising: An initial machine learning program (910) that includes standard instructions (940), meta-instructions (930), and random instructions (920); The initial machine learning program (910) uses a set of sigmoid curves (810) and almost step functions (820) in its network (840); A random system (248) that executes random instructions (920); A self-modifying system (250) that executes meta-instructions (930) to construct a new non-linear function, which is a combination of a sigmoid curve or an almost step function; The self-modifying system (250) adds the new non-linear function (850) to the network of non-linear functions of the machine learning program (950); A storage system (246) that stores the self-modified machine learning program (950).

11. The system according to claim 9, Comprising: An initial machine learning program (910) that includes standard instructions (940), meta-instructions (930), and random instructions (920); The initial machine learning program (910) executes a gradient descent program on its network of non-linear functions (850); A random system (248) that executes random instructions (920); A self-modifying system (250) that, when executing the gradient descent program, executes meta-instructions (930) to self-modify the gradient descent program; Store the self-modified machine learning program (950) in a storage system (246).

12. A machine-implemented method for performing calculations, Comprising: The machine includes a processor system (252), a storage system (246), an input system (242), and an output system (240); The processor system (252) executes machine instructions, which include standard instructions (110), random instructions (140), and meta-instructions (120); The random instructions perform random measurements (130) when executed; Store the results of the random measurements (130); And the machine modifies its instructions when executing at least one meta-instruction; Wherein, the standard instructions are executed sequentially; Wherein, the machine executes an initial machine learning program (910), and the machine instructions include random instructions (920), meta-instructions (930), and standard instructions (940); Wherein, by using an affine function that maps the standard instructions (940) into the complex plane, any standard digital computer program is converted into a geometric problem in the complex plane.

13. The method according to claim 12, Wherein, When executing the random instructions, the random measurements (130) measure one or more quantum events (170).

14. The method according to claim 12 or 13, Comprising: The machine changes the machine learning program (950) by executing one or more meta-instructions (930), And executes one or more random instructions (920); Wherein, the machine learning program (950) evolves continuously during its execution.

15. The method according to claim 14, Comprising: The initial machine learning program (910) uses a set of sigmoid functions (810) and almost step functions (820) in its network (840); The machine executes random instructions (920) and meta-instructions (930) to construct one or more new non-linear functions, which are combinations of sigmoid functions (810) and almost step functions (820); And the machine adds the newly constructed non-linear functions (850) to the network of non-linear functions (850) of the machine learning program (950).

16. The method according to claim 14, Comprising: The initial machine learning program (910) executes a gradient descent program on its neural network (830) or the network of non-linear functions (850); When executing the gradient descent program, the machine executes random instructions (920) and meta-instructions (930) to self-modify the gradient descent program; When self-modifying the machine learning program (950), the machine calculates at least one of the following: differential form, curvature tensor, or curvature of a saddle point, To help improve the gradient descent program; Store the evolved machine learning program (950).

17. A machine-implemented method, Comprising: The machine has a processor system (252) and a storage system (246); Wherein, the machine has one or more random instructions (920); When executing the random instructions (920), random measurements (130) are performed during the execution of the first instance; And a first result is generated; During the execution of the random instruction (920), a random measurement (130) is performed during the execution of the second instance; and a second result is generated; wherein, the first result is different from the second result; wherein, if the first result is selected, the first machine learning program (950) starts to execute; wherein, the first machine learning program (950) is capable of performing calculations using standard instructions (940), random instructions (920) and meta-instructions (930); if the second result is selected, the second machine learning program (910) starts to execute; wherein, the first machine learning program (950) includes a list of instructions different from those of the second machine learning program (910); wherein, the standard instructions are executed sequentially; wherein, during the execution of the random instruction, the random measurement (130) measures one or more quantum events (170); wherein, by using an affine function that maps standard instructions (940) to the complex plane, any standard digital computer program is converted into a geometric problem in the complex plane.

18. A non-deterministic machine, comprising: The machine has a processor system (252) and a storage system (246); wherein, the machine has one or more instructions stored in the storage system (246); wherein, each non-deterministic machine instruction has a probability of being executed; wherein, the set of all non-deterministic machine instructions is called a non-deterministic program; wherein, the probability of each instruction jointly forms a probability distribution over the set of all instructions in the non-deterministic program; wherein, according to the probability distribution of the instructions in the non-deterministic program, the next instruction to be executed is selected based on the result of a combined one or more random measurements (130); wherein, the standard instructions are executed sequentially; wherein, the execution of the non-deterministic machine is performed using standard instructions (110) and random instructions (140, 150); wherein, by using an affine function that maps standard instructions (110) to the complex plane, any standard digital computer program is converted into a geometric problem in the complex plane.

19. The machine according to claim 18, wherein, the random measurement (130) measures one or more quantum events (170).

20. The machine according to claim 19, wherein, the quantum events (547, 557) are the arrival of photons.

Images