Quantum Malware: Hacking Quantum Dense Coding

The next revolution in information and communications technologies (ICTs) will come from a development of a Quantum Internet (QI), integrating quantum communications and quantum artificial intelligence (QAI), with companies and states cooperating and competing on a strategic advantage over the development of quantum technologies: the race for quantum supremacy. The development of an artificially intelligent quantum world wide web may produce a new civilizational jump, greater than the Fourth Industrial Revolution.

In terms of foreseeable quantum technologies integration scenario, the most probable one is an accelerated integration of quantum computation and quantum communications in a hybrid quantum/classical infrastructure, until a full transition is achieved, as the research on nanotechnology and biotechnology is synergized with the research on quantum technologies, cloud and edge computing, quantum biology and open quantum systems, from the moment in which the full transition is achieved, quantum technologies will become the disruptive driver of the above-mentioned civilizational transition.

In this context, and given the accelerating pace of innovation in quantum technologies, the issue of quantum cybersecurity becomes an urgent point, an area of scientific and technological research that may begin with military applications, but then will progressively become integrated with the Internet of Things (IoT), and the Artificial Intelligence of Things (AIoT).

By the time in which a full-blown QI is achieved, the cyber-physical-cognitive (CPC) revolution, that characterizes the Fourth Industrial Revolution, will be well underway, which means that an advanced QI will be integrated within a smart world wide web, where nanotechnology, biotechnology and quantum technologies will intermix and reinforce each other.

This future is exponentially near, we are already using nanotechnology and biotechnological hybridization to expand computing, companies and states are already in a race for the development of quantum technologies, a race where China has officially established landmarks in regards to quantum communications, but, at the black budget advanced research level, we cannot know how far ahead countries like the USA or Russia currently are, an arms race involves some secrecy, and there is a certain tradition to assure a strategic advantage first at a classified level before official disclosure.

Also, at the level of quantum biology, the occurrence of quantum dynamics in biological systems may offer a way for the development of new directions into quantum technologies and open quantum computation.

From a computer science standpoint, a reflection on cybersecurity within the context of quantum computation and communications is, thus, becoming urgent.

In previous articles for this blog, we addressed quantum hacking games, which may form the future of hacking in the context of a quantum technological infrastructure. In this article, we take this a step further, providing an example of a quantum malware attack that is intended to disrupt quantum dense coding, and we simulate the attack using IBM’s Quantum Computers.

The context of the current article's problem is set in a future scenario, characterized by a sufficiently advanced quantum technological setting, where a person’s interface with quantum technologies involves a standard high-level user interface, under which that person’s interaction and commands are automatically encoded into quantum “machine language”, which involves an automated translation of a person’s interaction patterns and intended actions into qubits and quantum circuits. In this scenario if a person’s systems have been hacked with installed quantum malware, this may lead to a corruption of the interaction with the quantum computational and communicational infrastructure, without that person realizing it.

From a hacker’s standpoint this is not about eavesdropping on a quantum communications channel, but rather about installing malware that can disrupt quantum communications. The malware, in this case, has a translation to quantum operations that are automatically performed without the user realizing it. Like a classical computer virus that can corrupt a system’s function, the quantum malware becomes the next frontier in hacking when faced with a quantum computational and communicational infrastructure.

In this blog post, we take a step further into our research and production of educational materials for this next frontier of cybersecurity and hacking and show an example of a quantum malware that attacks the quantum dense coding protocol.

The Jupyter notebook for the current article is available at our “Quantum Cybersecurity” research project Github page: https://github.com/cpgoncalves/Quantum-Cybersecurity under the Jupyter file named “DenseCodingHack”.

Quantum dense coding uses entanglement and quantum interference to allow Alice to communicate two classical bits to Bob, sending only one qubit. In this case, Alice and Bob begin by sharing a Bell pair:

Even though Alice and Bob may be physically separated, their qubits are entangled. We assume, in the representation above, that Alice’s qubit comes second and Bob’s qubit comes first.

Depending upon the message that Alice wants to send, a number of different local operations may be implemented on her end, there are four possible algorithms for Alice’s quantum automated communication system, after automatically applying these local operations, Alice’s terminal sends Alice's qubit to Bob whose, also automated, system will then apply a controlled NOT (CNOT) gate, conditioned on Alice’s qubit, followed by the Haddamard transform, applied to the qubit received from Alice’s system, then Bob’s terminal will measure both his qubit and Alice’s and read the result.

Now, as stated, we assume, for the sake of our quantum cybersecurity scenario, that Alice and Bob are in a future where quantum computation and quantum communications have become sufficiently developed so that there is an automation of the translation of high-level instructions to the (quantum) machine language, what we mean by this is that Alice just types in the message (one of four possible messages, in this case) that she wants to send Bob and this gets automatically translated into one of four bit strings {00,01,10,11} which is then transferred to one of four corresponding sequence of quantum operations that will lead to the desired result under the established quantum dense coding communication protocol.

Bob, on his end, will also have the process automated so that neither Alice nor Bob are looking at the actual contents of the quantum circuit. Furthermore, we assume that Bob is not actually looking at the message in bits, namely, the bit string activates some automated system on Bob’s end that will respond and interact with Bob in accordance with Alice’s message. We are not addressing the specific messages that Alice may be sending, to keep things general, thus, we just assume that Alice sends one of four messages, and that the system automatically differentiates between one of these four messages using the classical bit strings in the set {00,01,10,11}, the translation on Bob's end from these bit strings to actual high-level messages are not also being addressed here, we will however discuss the issue of the uncovering of the hack, if that hack occurs, further on.

Considering the standard quantum dense coding without the hack, in the general scenario under analysis, the adaptive quantum circuit composition is fully automated and is like a black box for both Alice and Bob, who are like standard users that know nothing about the actual workings of quantum computation nor do they care about it, all they know is how to interact with the high-level interface not looking "under the hood".

The above is a very important point, we are assuming an advanced stage of automation and integration of CPC-systems with quantum communications' infrastructures, in such a way that the people in the communication circuit are not quantum experts and the whole quantum infrastructure works in the background. This will be key to illustrate the dangers and effectiveness of quantum malware, since Alice and Bob may think that their automated systems are working and it may take a while for them to realize that something is wrong.

Let us, then, simulate the process for each pattern without the malware and with the malware, showing the equations and then the results from running the simulations on IBM’s quantum computers for a few examples.

If Alice types in on her terminal the message that is represented by a string 00, then, the automated quantum communications' system just sends Alice’s qubit to Bob, whose terminal automatically applies a CNOT gate, using Alice’s qubit as the control, and then performs a Haddamard transform on Alice’s qubit, assuming, in the formal Dirac bra-ket representation, that Bob’s qubit is the first and Alice is the second we get:

In the first step, under the CNOT gate, Bob’s qubit remains unchanged in the branch where Alice’s qubit is |0> and is flipped in the case where Alice’s qubit is |1>, thus, given the entanglement pattern, this leads Bob’s qubit to |0> in both branches and Alice’s qubit to the symmetric superposition |+>, now, by applying the Haddamard transform on Alice’s qubit, there is a wavelike destructive interference for the alternative where Alice’s qubit is |1> and a constructive interference for the alternative where Alice’s qubit is |0>, leading to the final configuration |00> which is measured at Bob’s end, producing the intended result.

The circuit, for the above communication dynamics, to be simulated on IBM’s quantum computers, has the following structure:

The section before the first barrier corresponds to the preparation stage of the entangled pair. The section between the first and second barrier corresponds to Bob’s automated operations.

In an 8192 runs’ simulation using the quantum device 'ibmq_london', we got the following result.

As expected, the string 00 is the dominant pattern with a relative frequency of 0.959. Deviations from this pattern result from noise. One possibility for dealing with this noise is, of course, redundancy, in that the communication circuit is run multiple times and then one uses a criterion such as taking, for instance, the solution that has more than 80% relative frequency, which in this case would be 00.

Now, let us assume that Eve has installed malware on Alice’s system, and that whenever the automated command is sent on Alice’s end to send the qubit to Bob’s system, a Z gate is automatically applied to Alice’s qubit, a transformation that is applied for all the cases of hacked dense coding (we will discuss this point further on), then, the entangled configuration, resulting from the quantum malware attack, is:

Now, when Alice’s automated system sends the qubit and Bob’s system applies the usual protocol we get:

The consequence of Eve’s malware was to change the pattern of wave-like interference on Alice’s qubit, now the destructive interference happens for the alternative |0> and the constructive interference happens for the alternative |1>, which leads to the final configuration |01> to be measured, instead of the correct configuration |00>.

The corresponding circuit that simulates this dynamics on IBM’s quantum computers is:

Again, before the first barrier we have the preparation of the Bell pair, then is Eve’s hack, followed by Bob’s automated transformations.

If we run this circuit on the actual quantum device 'ibmq_london', with 8192 runs, we get the following results.

The results show the consequence of the quantum malware, now the dominant frequency is 01 and not 00.

Now, for the case with no malware and in which Alice’s alternative message corresponds to the bit string alternative 10 instead of 00, then, Alice and Bob’s automated protocol to be simulated in IBM’s quantum computers is given by:

In this case, considering the process from the Bell pair forward (that is after the entangled pair preparation stage), the protocol is such that Alice’s automated process first applies the X gate, which transforms the Bell pair into the following configuration:

Then Alice’s automated process sends her qubit to Bob’s system, which applies the same operations as before, leading to the sequence:

Simulating on IBM’s 'ibmq_london', with 8192 runs, we get the following results.

Which shows that the dominant result with 0.882 relative frequency is 10, the correct result.

Now, again, if the quantum malware is activated, Eve’s scheme is such that whatever the bit string that is to be obtained at the end of the quantum dense coding protocol, the malware always performs a Z gate transformation on Alice’s qubit before it is sent to Bob, that is, at the end of Alice’s automated operations, this change in the circuit always happens without Alice and Bob knowing about it. In this case, when Alice wants to send the message encoded as 10, we get the hacked automated sequence at Alice’s endpoint:

Now, when, at Bob’s endpoint, the usual automated sequence of transformations is performed, but in this case we get:

That is, instead of 10 Bob’s system receives 11.

If we simulate the protocol with the malware in IBM’s quantum computers we get, as expected, the result 11 as the dominant one, as the following figure shows.

In the Jupyter notebook “DenseCodingHack”, available at the quantum cybersecurity project's homepage https://github.com/cpgoncalves/Quantum-Cybersecurity, the implementation of the Qiskit functions for running this hacking game are shown and implemented for each of the four strings {00,01,10,11}. In each case, Eve’s malware scheme is always the same, the malware always applies a Z gate at the end of Alice’s computation, which means that Eve does not need to measure Alice’s qubit to compromise the communication protocol, she just has to perform a basic unitary operation to compromise the protocol.

Considering the notebook, and the above argument, we get an insight into a major cybersecurity issue, as quantum communications become integrated into the Internet, as quantum computation becomes accessible through remote access and as increasing budget and research is poured into the development of a quantum computational and communicational infrastructure, combining QAI, automation and communication protocols, the interface with this quantum infrastructure will not be one in which a person directly programs the quantum circuits, rather, a high-level interaction will necessarily be put in place, making it accessible for any person to use standard applications, including communication solutions, without caring about the underlying quantum implementation.

The users of future quantum technologies will not be seeing the translation from their high-level interaction with devices to the quantum machine language, which implies an automation process that bridges the user interface to the adaptive quantum circuit design using, for instance, Python programming integrated with Qiskit, the above referred Jupyter notebook constitutes a good example of the first steps in this direction.

Hackers who are trained in quantum computation and communications may design malware that is targeted at the automated bridge between the user interface and adaptive quantum circuit design for running things on the quantum substrate, it is at this level that quantum malware enters into play, in the sense that a hacker may target the automated bridge and change the circuit design response with specific quantum gate sequences that may disrupt the results of quantum computations and communications, depending on the type of applications, the users may realize what has happened immediately or may take some time realizing it, which can have disruptive effects.

In this sense, when developing quantum algorithms, we need to be aware of the hacking possibility and search for ways to hack a quantum algorithm, also searching for ways to counter a quantum cyberattack.

Quantum Random String Generator using IBM's Quantum Computers

Our goal in this new blog article is to use quantum computers to produce a random binary string, where each bit in the string is randomly chosen. In cryptography, the generation of random strings, and random numbers in general, is an important application, quantum Computers can be applied to random string generation, using the computer as a random number generator, taking advantage of the "statistically observed" "quantum randomness".

So far we have worked our examples only using the circuit composer. In this article we work with Qiskit functionalities, our goal is to use the Python programming language and the package Qiskit to build a quantum random binary string generator, taking advantage of quantum parallelism and "quantum randomness", thus, to get a string of size $N$ we use $N$ quantum registers.

The first step is to import the main functionalities. which is done next:

In [3]:

%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.visualization import *
import numpy as np
# Loading your IBM Q account(s)
provider = IBMQ.load_account()

Having imported what we need, we are now ready to define the two main functions in the Python programming language.

The first function is the "setup_circuit" function that sets the quantum circuit so that each quantum register works as a basic coin. Which means that if our intended random binary string is of size $N$ we need the same number of quantum registers and the same number of classical registers.

Each quantum register will undergo an independent Haddamard transform and then it is measured, which makes the circuit generate each bit with a 1/2 probability (a point to which we will return further on).

The first function takes as inputs the string size and the backend on which to run the program and returns:

a) The device on which the circuit will be run (this is needed for the cloud access to IBM's quantum devices);

b) The quantum circuit that is to be run.

The second function, which we called "get_string" takes as inputs the device, the circuit and the number of shots. Now, if the number of shots is set to 1, the "get_string" function uses the cloud access to run the quantum circuit with one single shot (one single experiment), printing the binary string. If the number of shots is set to more than 1, the function prints the counts results and returns the counts for further processing.

In the Python code, we wrote the comments as pedagogical notes to provide an added explanation into the main structure of the code.

In [19]:

# Setup the circuit function
def setup_circuit(size_string, # size of random string
                 backend='qasm_simulator' # backend to be used, default is set to 'qasm_simulator'
                 ):
    
    # Get backend
    if backend == 'qasm_simulator':
        device = Aer.get_backend(backend) # use Aer if the backend is the 'qasm_simulator' (default)
    else:
        device = provider.get_backend(backend) # use the provider otherwise

    
    # Setup the circuit (in the circuit we need the same number of quantum and classical registers)
    circuit = QuantumCircuit(size_string,size_string)
    
    # We use a for loop to setup the quantum gates 
    # so that for each quantum register apply the Haddamard transform, this is the unitary
    # evolution stage
    for i in range(0,size_string):
        circuit.h(i)
    
    # We use another for loop to setup the measurement process
    for i in range(0,size_string):
        circuit.measure(i,i)
    
    # Return the device for implementing this circuit and the circuit with the above structure
    return device, circuit

# Get the string function
def get_string(device, circuit, num_shots):

    # Execute the circuit on the device for the number of shots defined
    job = execute(circuit, device, shots=num_shots)
    
    # Get the results
    result = job.result()
    
    # Get the counts
    counts = result.get_counts(circuit)
    
    # Either print statistical results for the problem or return a single random string
    if num_shots > 1:
        # If the number of shots is greater than 1 print the counts and return the counts
        # for further processing, for instance, plotting or calculating other statistics
        print(counts)
        return counts
        
    else:
        # If the number of shots is equal to 1, then, the print the single randomly generated string
        for key in counts.keys():
            if counts[key] == 1:
                print(key)
                break

Having defined the functions, we are now ready to implement our Qiskit Python code. The first example that we provide is the generation of a random string with 100 digits. We cannot run this on the actual IBM physical devices, since it has more quantum registers than the available devices, which means that, in this first example, we will work with the simulator, which is used by default in our defined Python functions.

In [18]:

# Setup the string
device, circuit = setup_circuit(100)

# Run the string
get_string(device,circuit,num_shots=1)

0011000101100001001100100101110110001110011110110110010101111100010000110010100100001100111111010010

The following experiment is run on the Burlington device, which is a 5 qubit actual quantum computer. In this experiment we use the five registers for a random generation of a 5 bit string.

In [20]:

device, circuit = setup_circuit(5,'ibmq_burlington')

get_string(device,circuit,num_shots=1)

00101

To get a string larger than 5, we need a quantum computer with a larger number of qubits, the next experiment works with the Melbourne device and extracts a random string of 5 qubits.

In [21]:

device, circuit = setup_circuit(15,'ibmq_16_melbourne')

get_string(device,circuit,num_shots=1)

111000110000001

Let us now generate multiple strings of size 6, running the program on a quantum computer with multiple shots to see the statistical results that we may get from running the quantum program multiple times. We are still using the Melbourne device.

In [25]:

device, circuit = setup_circuit(6,'ibmq_16_melbourne')

counts = get_string(device,circuit,num_shots=1000)

{'110010': 11, '100010': 13, '000101': 27, '100110': 12, '111111': 9, '010100': 21, '100001': 20, '011110': 14, '111011': 6, '101000': 17, '011111': 10, '011000': 21, '010110': 22, '101101': 20, '101111': 13, '110110': 20, '001001': 12, '001110': 24, '010010': 14, '100100': 10, '101100': 13, '001011': 19, '001101': 19, '001000': 16, '000100': 22, '000010': 27, '100000': 22, '000011': 22, '111000': 11, '000111': 22, '110000': 7, '001100': 13, '100111': 16, '010001': 15, '010000': 19, '010011': 10, '110011': 10, '000110': 27, '001010': 13, '100011': 16, '001111': 16, '111001': 12, '111101': 9, '111100': 11, '011001': 13, '100101': 14, '110001': 6, '010111': 15, '110100': 17, '000001': 32, '000000': 35, '101010': 10, '110111': 11, '011010': 10, '011101': 13, '111110': 11, '010101': 11, '101011': 14, '101110': 20, '011100': 15, '101001': 17, '111010': 11, '110101': 11, '011011': 11}

Now, with the Burlington device and three qubit registers, the following code calculates the Histogram, using the get_string function to print and get the counts that are then used to plot the histogram.

In [14]:

device, circuit = setup_circuit(3,'ibmq_burlington')

counts = get_string(device,circuit,num_shots=8192)

plot_histogram(counts)

{'001': 1208, '111': 957, '100': 985, '010': 994, '101': 987, '110': 894, '011': 1066, '000': 1101}

Out[14]:

While there are some differences in the above histogram's bars, the results are close to $(1/2)^3=0.125$, the difference is due to the fact that a sample of experiments is being plotted, as the number of experiments rises, the relative frequencies will tend to the true probability $(1/2)^N$. We can see this convergence occurring more for a lower string size, as the following experiment shows.

In [15]:

device, circuit = setup_circuit(2,'ibmq_burlington')

counts = get_string(device,circuit,num_shots=8192)

plot_histogram(counts)

{'01': 2031, '00': 2129, '10': 1823, '11': 2209}

Out[15]:

Let us now write a new function, in this case, to calculate the experimental entropy for repeated runs of the circuit.

The first point that we need to stress is that, for the ideal system, where the unitary evolution holds perfectly, which corresponds to the case of the ideal computer without errors, the entropy is null for the pure density that results from the unitary evolution stage. Given the circuit's structure, where the evolution for each quantum register is independent, we can address the process in terms of the local evolution for each register, which, in this circuit, is the same for each of them.

First, under the unitary evolution, each register's quantum dynamics leads to an equally weighted superposition of |0> and |1>, which is described by the symmetric ket $ |+> = (|0> + |1>)/sqrt(2) $, which, expressed as a density operator, leads to the local transition for each quantum register:

$ |0><0| -> |+><+| = (|0><0| + |0><1| + |1><0| + |1><1|)/sqrt(2) $

Now, considering the "classical register" for each quantum register, which corresponds to our measurement apparatus and including, in our description, the "rest of the world" that we write as "World", the quantum measurement leads to the following density after measurement:

$ A = |+,C,World><+,C,World| $,

where the ket |+,C,World> is the entangled result:

$ |+,C,World> = (|0,C_0,World_0>+|1,C_1,World_1>)/sqrt(2) $.

Now, since we are part of the rest of the world and we only see the results from the classical register, we can address our knowledge in terms of the register plus rest of the world configuration, which leads to the reduced density:

$ R = 0.5*|C_0,World_0><C_0,World_0|+0.5*|C_1,World_1><C_1,World_1| $

Therefore, we have a classical mixture with one branch corresponding to a world where the classical register (measurement device) registers the value '0' which is returned and seen by us, and a world where the classical register (measurement device) registers the value '1' which is returned and seen by us. The resulting von Neumann entropy, measured in the base 2, for this last density, is equal to 1 bit, which is a maximum entropy value.

Likewise, if we consider all of the registers then we get the tensor product of $N$ copies of the density R, leading to an entropy equal to $N$ bits, therefore, each register's (measurement) results are similar to an idealized balanced coin, and the $N$ registers behave similar to $N$ coin tosses, or, in this case, $N$ coins being tossed.

It's important to stress that, different interpretations of quantum mechanics will interpret the above results differently, however, we will not be discussing here these different interpretations, we are mostly interested, from a quantum cybersecurity applications' standpoint, in testing the randomness of the experimental process, namely, we want to test whether the distribution over the binary strings obtained from the measurement process is effectively close to the maximum entropy result, which indicates that the quantum computer does what we wanted, that is, to produce strings of binary digits that behave like the result of an "idealized" balanced coin toss.

The following Python allows us to obtain this evaluation.

In [5]:

def calculate_entropy(device,circuit,num_shots):
     # Execute the circuit on the device for the number of shots defined
    job = execute(circuit, device, shots=num_shots)
    
    # Get the results
    result = job.result()
    
    # Returns counts
    counts = result.get_counts(circuit)
    
    # Calculate and print the entropy
    
    H=0
    
    for key in counts.keys():
        p=counts[key]/num_shots
        if p != 0:
            x = -p*np.log(p)/np.log(2)
        H += x
    
    print("Entropy value", H)

Let us now run the function for a quantum single register, on the Burlington device.

In [16]:

device, circuit = setup_circuit(1,'ibmq_burlington')

calculate_entropy(device,circuit,num_shots=8192)

Entropy value 0.999966291137892

The value obtained in our run was 0.999966291137892, slightly lower but very close to 1 bit. Let us now run the experiment for 2 registers

In [17]:

device, circuit = setup_circuit(2,'ibmq_burlington')

calculate_entropy(device,circuit,num_shots=8192)

Entropy value 1.9976699397719135

In this case, we got the number 1.9976699397719135, which is also lower but close to 2 bits. For a Final experiment let us run the circuit with 6 registers, on both the "qasm" simulator and the Melbourne device. In the case of the "qasm" we use 100,000 repeated trials, in the case of the Melbourne device we will use 8,192, which is the largest value that we can set.

In [10]:

device, circuit = setup_circuit(6)

calculate_entropy(device,circuit,num_shots=100000)

Entropy value 5.999594101018126

In [11]:

device, circuit = setup_circuit(6,'ibmq_16_melbourne')

calculate_entropy(device,circuit,num_shots=8192)

Entropy value 5.980928055437641

In both cases we got values lower but close to the maximum entropy.

Why is this?

Well, first we will never get a value larger than the maximum entropy, otherwise it would not be maximum, secondly, in any finite number of experiments, we can expect to get relative frequencies close to the theoretical values but not exactly equal, since the probability is the number to which the relative frequencies tend as the number of trials rise, which means that we can expect, on a finite number of experiments with random number generation (quantum or not), lower values than the maximum but, as long as the random number generator is working properly, close to the maximum.

When we use a pseudorandom number generator, we are using a method for random number generation that is actually deterministic, the same "pseudorandomness" holds for the device 'qasm_simulator', on the other hand, when we run the experiment on the actual quantum computers, we are using quantum randomness to generate the strings. Since the probability for each result is close to the balanced coin toss we get very close to our intended profile of random binary string generation.

There is, of course, one point that can be risen: is quantum randomness true randomness? That is a problematic question on three points:

1) What does "true randomness mean"? 2) What does "being random" mean? 3) What is "quantum randomness"?

From a practical standpoint, we can satisfy ourselves that the quantum computers produce a result that closely approximates our models/mathematical criteria for randomness, in terms of probability theory. In that sense, the pragmatic and, perhaps, safer answer would be that the quantum computer running our Python coded algorithm does behave like a random number generator that closely approximates our model of a balanced coin, which means that it works as far as our technological intention goes.

The Philosophical reflection on "true randomness" and "quantum randomness" leads us to the questions of truth, reality, randomness, order and the quantum dynamics. In this regard, we have no final answer, in the sense that quantum theory's formalism is, so far, open to different interpretations, all consistent with the same formalism but that differ in regards to their stance on "reality", "randomness" and the "quantum dynamics", so the question "is quantum randomness true randomness?", for now, ends in the question mark, while, at the same time, we do the calculations and run our algorithms on quantum computers that work in accordance with the formalism and behave for all practical/applicable purposes in accordance with the probabilistic conception of randomness.