Validating quantum computers using randomized model circuits — Quantum Volume

Measuring the Quantum Volume of Quantum Devices and running a circuit in Qiskit to find QV.

20 min readJun 16, 2023

Link to the paper : [1811.12926] Validating quantum computers using randomized model circuits (arxiv.org)

Quantum computing has captivated scientists, researchers, and tech enthusiasts with its potential to revolutionize computational power and solve complex problems beyond the reach of classical computers.

As this remarkable field continues to progress, measuring and evaluating the capabilities of quantum processors becomes essential. One such metric that serves as a benchmark for assessing the power and quality of quantum devices is the Quantum Volume. In this article, we embark on a journey to explore the concept of Quantum Volume, its significance, and its implications for the future of quantum computing.

Quantum Computing can be used in many disciplines and can be implemented in several ways, each one with different characteristics, so the question immediately arises:

Which quantum technology is the most useful and How can we compare them?

There are some desirable properties of a quantum computer, like more qubits, better connectivity, a very low rate of error, a very high coherence time etc. However , each technology is better at some and worse at some, so you can’t simply compare them straightforward. So we need to have a benchmark test of performance for these, like we use to have for optimization solvers ( where they compare CPLEX, GUROBI etc) or a test like LIN PACK , where they compare the fastest supercomputers. This benchmark measures how many double precision floating point operations per second (FLOPS) a computer can achieve when solving a linear equation system using the LU factorization with partial pivoting.

In the paper, the authors introduced a single-number metric , Quantum Volume , which can be measured using a concrete protocol on near-term quantum computers of modest size (n<50). This Quantum Volume is linked to systems error rates, and is empirically reduced by uncontrolled interactions within the system.

Quantum Hardware

There are a wide variety of physical system proposed as qubit implementations:

Right now, the technologies that are showing the most promising results are superconducting circuits and ion traps.

Superconducting qubits

These qubits consist of circuits with no resistance to the flow of electrical current that are manipulated with microwave pulses.

The Good

Superconducting qubits have gate times of around 100 ns, and gate fidelity close to 99% for 2-qubit gates. However, they are very scalable thanks to the possibility of adapting existing technologies like microchips. IBM’s latest quantum processor Eagle has 127 superconducting qubits, and the IBM’s Osprey has 433 qubits.

The Bad

Nonetheless, the connectivity is limited to neighboring qubits and the coherence time is low, around 50 or 100 µs.

The Ugly

Other restrictions this type of qubit has are that it requires temperatures close to 10 mK and that superconducting qubits are not all identical due to nano-fabrication variations, so they need to be calibrated separately.

Illustration of a four-qubit superconducting quantum processor fabricated by IBM Quantum circa 2017. (from IBMs Qiskit)

If you want to learn more in detail about superconducting qubits and how they work, that article will come soon. Same for Ion Trap qubits.

Ion Traps

This type of qubit consists of ionized atoms trapped in a lattice by oscillating electromagnetic fields. The gates are implemented via laser pulses.

The Good

Ion traps have high coherence times, close to 1s , and all-to-all connectivity. Their gates have better fidelity than those of superconducting qubits (around 99.9% for 2-qubit gates)

The Bad

However, they have slower gates of around 10 µs for 2-qubit gates and are not easily scalable because increasing the number of ions creates mutual interference. For instance, IonQ’s latest quantum computer, Ion Q Forte has 35 qubits.

The Ugly

The technologies necessary to implement them are not as mature as the ones in superconducting qubits.

A Ion trapped in potential. (GIF taken from PennylaneAI)

The Quantum Bench-marking

This section is inspired from this paper. Read it here : [2110.14108] Quality, Speed, and Scale: three key attributes to measure the performance of near-term quantum computers (arxiv.org)

There are different metrics that describes the efficiency and power of a quantum computer, depending on what we focus on, quality or speed.

Device Benchmarks:

They consist of properties that are intrinsic to the device itself, like the coherence times T1 and T2, the cross-talk between qubits and qubit connectivity. These benchmarks don’t consider any job or process performed by the device.

Subsystem benchmarks:

They characterize the performance of part of the device, that is, a subset of qubits. They are influenced by the device benchmarks but subsystem benchmarks generally cannot be fully explained from them.

Holistic benchmarks:

They measure how successfully the quantum computer as a whole can carry out a specific task. They are affected by the above benchmarks, but it is much harder to determine how each one affects the outcome and their importance.

Quantum Volume test is a Holistic benchmark.

Bench marking pyramid showing how quality and speed can be bench marked. Higher-level benchmarks capture more complexity but less specificity. There may be tradeoffs between the two faces of the pyramid. From the paper : [2110.14108] Quality, Speed, and Scale: three key attributes to measure the performance of near-term quantum computers (arxiv.org)

Quantum Volume

The quantum volume is a pragmatic way to measure and compare progress toward improved system-wide gate error rates for near-term quantum computation and error-correction experiments.

The idea behind quantum volume is to look for the biggest random square circuit that can be successfully executed on a specific quantum computer. If d is the highest width (number of qubits) and depth achieved, then the quantum volume is 2^d.

It is well known that quantum algorithms can be expressed as polynomial-sized quantum circuits built from two-qubit unitary gates. Hence they are not random circuits. However, random circuits model generic state preparations, and are used as the basis for demonstrating the quantum advantage.

The Circuit

A model circuit shown here with depth d and width m

**Model Circuit**: A model circuit consists of d layers of random permutations of the qubit labels, followed by random two-qubit gates. When the circuit width m is odd, one of the qubits is idle in each layer. A final permutation can be applied to the labels of measurement outcomes.

is a sequence of d layers. Each labelled by times t = 1,…,d and acting on m = 2[n/2] qubits.

Each of these layers consists of a random permutation of all the qubits in the circuit and then a random two-qubit unitary operator (SU(4) in this case) for each pair of adjacent qubits.

Substituting for the value of time steps and number of qubits, the above equation becomes:

where this πi is a uniformly random permutation of the qubits and each U is a random element of SU(4) acting on qubits a and b.

To define when a model circuit U has been successfully implemented in practice, we use the heavy output generational problem .

HOG, or Heavy Output Generation : Given as input a random quantum circuit C (drawn from some suitable ensemble), generate output strings x_1, …, x_k , at least a 2/3 fraction of which have the greater than the median probability in C’s output distribution.
HOG is easy to solve on a quantum computer, with overwhelming success probability, by the obvious strategy of just running C over and over and collecting k of its outputs

The ideal output distribution is

where x is an observable bit string. Consider that the set of output probabilities given by the range of above, is sorted in ascending order.

Probabilities in ascending order.

The median of the set of probabilities is

and they heavy outputs are

The Simulation

Once we have all this, we simulate the circuit classically. This is done in order to know the ideal probability distribution of the circuit outputs. It is particularly important to note that, given that this process is completely classical, the computational resources required scale exponentially with t, so this can become unfeasible for bigger circuits in the long term.

However, the current highest reported Quantum Volume is 4096 by Quantinuum, which is equivalent to a 12-qubit quantum circuit (since 2¹² = 4096). It’s based on Ion Trap technology.

Link to the article : Quantinuum Announces Quantum Volume 4096 Achievement

This plot shows the growth of measured quantum volume by Quantinuum. For each test, the heavy output probability `h` is listed and the system is identified by the marked type. The dashed grey line shows the target scaling of increasing Quantum Volume * 10 yearly. (picture taken from the same article)

If we consider that to store a complex number with double precision we need 16 bytes, 8 for real and 8 for imaginary, and an n-qubit state requires 2^n complex numbers, we deduce that to simulate a system with n qubits, we need a memory M of:

Memory required to simulate quantum circuit of n qubits.

If we work on with the IBM’s Summit supercomputer, whose RAM is 2,801,664 GB, using the above equation we can find how many qubits of quantum circuit it can simulate.

For a supercomputer with 2,801,664 GB of RAM we can simulate 47 qubits in a quantum circuit.

We know from the above section that, the set of heavy outputs from the circuit U are

where the p_med is:

So, how often should we expect to find heavy outputs on a random circuits. For a random SU(4) matrix, U, each

follows an exponential distribution with parameter λ=1 , that is

So, in order to find median of these probabilities, we need to find the value m that satisfies

After solving it we get (I’ve skipped the steps)

So the probability that a particular x is heavy is the result of the above equation divided by 2^d, that gives

This math follows from the paper : [1612.05903] Complexity-Theoretic Foundations of Quantum Supremacy Experiments (arxiv.org)

The Quantum Device

Now we have the list of heavy outputs of our quantum circuit, we will test it on an actual quantum computer and look out for cumulative heavy output probability (HOP) .

Running on an actual quantum device is not that easy as it may seem. The quantum device generally have limited connectivity, so some SWAP gates must be added. Also it may be possible that some gates are not supported , so we have to express them in function of other gates.

The objective is to get high enough percentage of heavy outputs. The probability of an ideal device should be around 0.85, as we saw in the previous section, but our current devices are far from ideal. On the contrary the worst case scenario, where we have a completely depolarized channel has a probability 0.5.

A middle ground between worst and the best case would be appropriate for our device, i.e around 0.675. Then if we run n_c circuits of dimension d for n_s times each and get n_h heavy outputs, a reasonable approximation of the probability h_d of getting a heavy output would be:

However it is not enough to get h_d > 0.675 to be sure our experiment is successful, given that we could be getting this result by chance. In order to ensure the significance of our outcomes, we need to resort to confidence intervals related to h* and h. So we get

where we set z= 2 for 97.5% 2-sigma one-sided confidence interval. For example, to claim success with 5000 model circuits (n_c) , the observed heavy fraction must exceed the threshold t = 0.68.

This Algorithm provide the pseudocode for testing when each h > 0.675

Hence we hot a metric that is a single real number, and enables a straightforward comparison.

Qiskit Implementation

Now we will learn how to do a Quantum Volume test with the help of Qiskit on IBM’s quantum computers, it’ll be a well detailed one and a step-by-step process.

First make sure to install necesaary packages and import all necessary tools:

# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile
# from qiskit.tools.jupyter import *
from qiskit.visualization import *
# from ibm_quantum_widgets import *

# qiskit-ibmq-provider has been deprecated.
# Please see the Migration Guides in https://ibm.biz/provider_migration_guide for more detail.
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Estimator, Session, Options

# Loading your IBM Quantum account(s)
service = QiskitRuntimeService(channel="ibm_quantum")

# Invoke a primitive. For more details see https://qiskit.org/documentation/partners/qiskit_ibm_runtime/tutorials.html
# result = Sampler("ibmq_qasm_simulator").run(circuits).result()

Firstly we have to decide on the number of qubits we are going to use. This will be the width and depth of the circuit. Since we are using the free IBM account that has access to few devices, we will be running our code on ibmq_jakartaandibmq_belem, both of which are 5 qubit devices.



# create a list with the qubits we want to use
qubit_list = [i for i in range(5)]

# save the length of the list = number of qubits = depth of the circuits = width of the circuits
SIZE = len(qubit_list)

The next thing we need are the random two-qubit unitaries, that we will apply on this circuit. Since our circuit is of 5 qubits (odd) and we are applying two-qubit (even) unitaries, one qubit will remain empty.

We’ll use the random_unitary function from qiskit.quantum_info.

from qiskit.quantum_info import random_unitary
# create a random 4x4 unitary matrix i.e. a random 2-qubit operator
random_unitary(4)

Since we have the desired gates, we will now apply them on the adjacent layer, and one qubit will left unchanged (odd-even)

from qiskit import QuantumCircuit

# create the circuit corresponding to the first layer
qv_layer = QuantumCircuit(SIZE)

# iterate over the pairs of qubits, of which there are the integer part of SIZE/2
for pair in range(SIZE//2):
    # choose indexes
    qubit_indices = qubit_list[pair * 2 : pair * 2 + 2]
    # create gate
    gate = random_unitary(4).to_instruction()
    # add gate to circuit
    qv_layer.append(gate, qubit_indices)

# show the layer circuit
display(qv_layer.draw("mpl"))

# show a more detailed version of the layer circuit
display(qv_layer.decompose().draw("mpl"))

The quantum circuit of 5 qubits, with adjacent two qubit unitaries.

The decomposed version of the same circuit.

This is what the circuit looks actually.

The next step will be creating a circuit with SIZE layers instead of only one. Before each layer we have to randomly create permutation of the qubits, what can be done with the shuffle function from random.

from random import shuffle

qlist = qubit_list[:]

# create the circuit
qv_circ = QuantumCircuit(SIZE)

# randomly permutate the list of qubits and add a layer SIZE = depth times
for i in range(SIZE):
    shuffle(qlist)
    for pair in range(SIZE//2):
        qubit_indices = qlist[pair * 2 : pair * 2 + 2]
        gate = random_unitary(4).to_instruction()
        qv_circ.append(gate, qubit_indices)

#show the circuit
display(qv_circ.draw("mpl"))

Quantum Circuits after randomly permutating the qubits before applying the unitaries.

If you don’t want to do all that, qiskit already has a class called QuantumVolume in their module qiskit.circuit.library that directly creates this kind of circuits for us so, in practice, we don't have to worry about how they are built.



from qiskit.circuit.library import QuantumVolume

qv_circ = QuantumVolume(SIZE)

qv_circ.decompose().draw("mpl")

Here SU(4) means matrices of Special Unitary. This is the circuit that will do the quantum volume test.

Now we’ll use the simulator aer_simulator from Aer to obtain the ideal probability distribution of the outputs of our circuit. In other words, we'll see what we should get if we ran our circuit with an ideal quantum computer.

from qiskit import Aer, transpile
from qiskit.visualization import plot_histogram

# define the simulator
simulator = Aer.get_backend("aer_simulator")

# transpile the circuit so it can be used with the simulator
t_qv_circ = transpile(qv_circ, simulator)

# save the statevector of the circuit
t_qv_circ.save_statevector()

# run the simulator to get the probability distribution from the statevector
counts = simulator.run(t_qv_circ).result().get_counts()

# represent the probability distribution with an histogram
plot_histogram(counts, figsize = (18,7))

Probability Distribution with an histogram

The part of the probability distribution that will be interesting to us is the heavy outputs, the outputs whose probability is higher than the median’s. We can select these values by ordering our list of outputs by probability with sorted and then selecting the second half of the indices.



# order the bars of the histogram by ascending probability
display(plot_histogram(counts, figsize=(18,7), sort='value'))

# sort the list of outputs by probability
sorted_counts = sorted(counts.keys(), key=counts.get)

# pick the heavy outputs
heavy_outputs = sorted_counts[len(sorted_counts)//2 : ]

# show the heavy outputs
print("The heavy outputs of this circuit are:", heavy_outputs)

The heavy outputs of this circuit are: [‘10011’, ‘11100’, ‘00010’, ‘10010’, ‘11111’, ‘10111’, ‘10100’, ‘01000’, ‘00110’, ‘01101’, ‘00101’, ‘00000’, ‘11010’, ‘00100’, ‘01011’, ‘01111’]

After getting our heavy output list we can start thinking about running our circuit with an actual quantum computer. One way of doing this is by using IBMQ.

from qiskit import IBMQ

# save IBMQ account
#IBMQ.save_account(api_key)

# load IBMQ account
IBMQ.load_account()

Once we have loaded the account, we need to choose a provider, from which we will be able to pick our desired device. As an IBM intern, I was granted access to the hub 'ibm-q-internal', which has a wider array of available computers than the free basic pack.

# select provider
%pip install qiskit_ibm_provider
provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main")

Let’s see what quantum systems we can have access to.

# show backends
provider.backends()

All the Quantum Devices that you have access to as you make a free IBMQ acccount.

We’ll use the 'ibmq_belem' backend.


# choose quantum computer
backend = provider.get_backend('ibmq_belem')

We can take a look into the coupling graph of the device, the error rate of each qubit, the CNOT error corresponding to each pair of qubits and the error rate of a Hadamard gate applied on each qubit using the plot_error_map function from the module qiskit.visualization.

from qiskit.visualization import plot_error_map # install seaborn first
plot_error_map(backend)

This shows the architecture of the device and also the error rate of the Hadamard and CNOT gates.

It is also possible to look into some of the properties of the each device by using the IBMQBackend.properties() method.

For example, we can look into the error rates of each CNOT gate to get a more exact description than the colors from plot_error_map, that can be obscured if there are some extreme values.



for i in backend.properties().gates:
    if "cx" in i.name:
        print(f"{i.name}, that acts on qubits {i.qubits} and has error rate of {i.parameters[0].value}")

Error rates of individual CNOT gates applied on the circuit.

In order to run the circuit on the quantum computer, we need to add measures to it. If this is not done, we will not get any significant result.

A quick way to do this is using the QuantumCircuit.measure_all() method, that automatically adds a classical register with as many bits as qubits we have in our circuit and measures all of the qubits into their corresponding bit.

After that, we run the circuit qv_circ several times, in this casen_shots = 1024, and check how many heavy outputs we got.

n_shots = 1024

# measure the circuit in order to get something meaningful from the quantum computer.
qv_circ.measure_all()

# show the circuit with the measures
display(qv_circ.decompose().draw("mpl"))

# transpile the circuit according to the backend
transpiled_qv_circ = transpile(qv_circ, backend)

# run the circuit on the backend
job = backend.run(transpiled_qv_circ, shots=n_shots)

# take the results
device_counts = job.result().get_counts()

# initialize number of heavy outputs
n_heavy = 0
# check if they are heavy outputs
for heavy_output in heavy_outputs:
    if heavy_output in device_counts.keys():
        n_heavy += device_counts[heavy_output]
n_heavy = int(n_heavy)

print("After running the circuit", n_shots, "times, we got", n_heavy, "heavy outputs")

After running the circuit 1024 times, we got 533 heavy outputs

Run the full Quantum Volume test

Now that we have seen how to create a quantum volume circuit, get its heavy outputs and run it on an actual quantum computer, it’s time to do the same for n_circuits different circuits.

We will first start by creating a list of circuits and another list with their corresponding heavy outputs.

from qiskit import Aer, transpile, QuantumCircuit, IBMQ
from qiskit.circuit.library import QuantumVolume
import numpy as np

# select the depth and width of the QV circuits
SIZE = 5

# number of times we will run each circuit
n_shots = 10000

# choose simulator
simulator = Aer.get_backend("aer_simulator")

# load IBMQ account
IBMQ.load_account()

# select provider
provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main")

# choose quantum computer
backend = provider.get_backend('ibmq_belem')

# number of different circuits set to maximum permitted per job with this particular backend
n_circuits = 1000

# initialize a list of all the circuits
circuit_list = []

# initialize list of heavy outputs
heavy_outputs_list = []


for circuit in range(n_circuits):
    # create the QV circuit
    qv_circ = QuantumVolume(SIZE)
    # transpile circuit to use the simulator
    qv_circ_simulator = transpile(qv_circ, simulator)
    # save the statevector of the circuit
    qv_circ_simulator.save_statevector()
    # get probabilities
    counts = simulator.run(qv_circ_simulator).result().get_counts()
    # sort the results by probability
    sorted_counts = sorted(counts.keys(), key = counts.get)
    # pick the heavy outputs
    heavy_outputs = sorted_counts[len(sorted_counts)//2 : ]

    # add heavy outputs to list
    heavy_outputs_list.append(heavy_outputs)

    # measure the circuit before running it through the quantum computer
    qv_circ.measure_all()

    # add the circuit to the list
    circuit_list.append(qv_circ)

# transpile the circuits so they can be run on the quantum computer
transpiled_circuits = transpile(circuit_list, backend)

The next step is, as expected, running the circuits on the backend. In theory we would only need to run backend.run(transpiled_circuits, shots=n_shots) but there are some limitations that we have to take into account.

Each device has a maximum limit of circuits allowed and, if we try to run more than that, we will get an error. This limit can be checked with the following command.

max_circuits = backend.configuration().max_experiments
max_circuits

100.

A possible way to circumvent this limit would be breaking the circuit list transpiled_circuits into lists of size max_circuits and a final list with the rest of executions and then checking for each circuit the number of heavy outputs obtained(this code takes a while to run).

# initialize the number of heavy outputs
n_heavy = 0

# we split the executions according to the maximum number of circuits allowed by the device
max_circuits = backend.configuration().max_experiments

for i in range(n_circuits//max_circuits):
    # run max_circuits circuits on the backend
    job = backend.run(transpiled_circuits[i * max_circuits : (i+1) * max_circuits], shots=n_shots)
    # take the results
    device_counts = job.result().get_counts()
    # check if they are heavy outputs
    for j in range(max_circuits):
        for heavy_output in heavy_outputs_list[i * max_circuits + j]:
            if heavy_output in device_counts[j].keys():
                n_heavy += device_counts[j][heavy_output]

if (i+1) * max_circuits != n_circuits:
    # run rest of circuits on the backend if there are any
    job = backend.run(transpiled_circuits[(i+1) * max_circuits : n_circuits], shots=n_shots)
    # take the results
    device_counts = job.result().get_counts()
    # check if they are heavy outputs
    for j in range(n_circuits - (i+1) * max_circuits):
        for heavy_output in heavy_outputs_list[(i+1) * max_circuits + j]:
            if heavy_output in device_counts[j].keys():
                n_heavy += device_counts[j][heavy_output]
n_heavy = int(n_heavy)

However, Qiskit also includes a job manager called IBMQJobManager that already handles this for us in a more optimal way.

from qiskit.providers.ibmq.managed import IBMQJobManager

# initialize job manager
job_manager = IBMQJobManager()

# run the circuits with the job manager
job = job_manager.run(transpiled_circuits, backend=backend, shots=n_shots)

An important detail when using the IBMQJobManager is that the way to get the results has a slightly different syntax than usual. For a standard job, we would run job.result().get_counts() to get a list of dictionaries, each one corresponding to a circuit. However, for this managed job, we can only get the dictionaries one by one with job.results().get_counts(i) for the -th circuit. Note that this time we change result for results.

# initialize the number of heavy outputs
n_heavy = 0

# initialize cumulated heavy output probability (HOP), individual HOP and interval
hop_cumulated = np.array([])
hop_individual = []
interval = np.array([])

for j in range(n_circuits):
    # initialize the number of heavy outputs of circuit j
    n_heavy_j = 0
    # get dictionary of results from circuit j
    device_counts = job.results().get_counts(j)
    # check which results are heavy outputs
    for heavy_output in heavy_outputs_list[j]:
        if heavy_output in device_counts.keys():
            n_heavy_j += device_counts[heavy_output]
    # add the heavy outputs of the circuit to the total count
    n_heavy += n_heavy_j
    # update individual HOP, cumulated HOP and interval
    hop_individual.append(n_heavyj/n_shots)
    hop_cumulated = np.append(hop_cumulated ,n_heavy/((j+1)*n_shots))
    interval = np.append(interval, 2 * np.sqrt( n_heavy * ( n_shots - n_heavy/(j+1)) )/(n_shots*(j+1)))

Now that all the circuits have been run, it’s time to check if the quantum volume is achieved. So we want to know whether

# show the parameters we'll use to determine the quantum volume    
print("n_c: ", n_circuits, "\nn_s: ", n_shots, "\nn_h: ", n_heavy) 

# determine if the quantum volume is achieved
if (n_heavy - 2 * np.sqrt(n_heavy * (n_shots - n_heavy / n_circuits)))/(n_shots * n_circuits) > 2/3:
    print("Success! Quantum Volume of", 2**SIZE, "achieved!")
else:
    print("Quantum Volume", 2**SIZE ,"test failed, ", (n_heavy - 2 * np.sqrt(n_heavy * (n_shots - n_heavy / n_circuits)))/(n_shots * n_circuits), "< 2/3")

n_c:  1000 
n_s:  10000 
n_h:  6052202
Quantum Volume 32 test failed,  0.5743055620747737 < 2/3

A way to see how close we got to actually passing the test, it is useful to visually represent the data. In particular we will plot the individual and cumulated heavy output probabilities, the latter of which will be surrounded by a shaded ±2σ region.



import matplotlib.pyplot as plt

fig, ax = plt.subplots(1,1)
ax.plot([0, n_circuits], [2/3, 2/3], '--', color = 'black')
ax.plot(range(n_circuits), hop_cumulated, '-', color = 'red')
ax.plot(range(n_circuits), hop_individual, '.', color = 'blue')
ax.fill_between(range(n_circuits), hop_cumulated - interval, hop_cumulated + interval, color = 'lightgrey')
plt.grid()
plt.ylim([0.4,1])
ax.legend(['Threshold', 'Cumulated HOP', 'Individual HOP', '2 $\\sigma$'], loc = 'lower right')

The Quantum Volume test would be passed if the lower part of the interval goes above the 2/3 threshold.

As we can see, the interval becomes narrower when the number of circuits increases. Generally, if the cumulated HOP is consistently above the threshold, it should be theoretically possible to pass the test with a big enough number of circuits.

However, this decrease of width becomes less noticeable when the number of circuits increases, so it can sometimes become unfeasible in practice.

Quantum Volumes of devices freely available to us through IBMQ.

Till now, we have only used the transpiler to insert the circuit into the desired device, without further optimizing the circuit. We can see that this result is nowhere close to the actual Quantum Volume which is reported by IBM. There are some algorithms that can improve the result that we have. Like the KAK decomposition method described in this paper:

Link to the paper : [quant-ph/0211002] An Arbitrary Two-qubit Computation In 23 Elementary Gates (arxiv.org)

Using the approximate decomposition, it takes the CX error rates as a parameter to determine acceptable approximation errors when synthesizing a circuit for an element of SU(4). This decomposition is applied assuming the CX error rates of 0.01, 0.03 and 0..05 and the result was compared. There was a modest increase the h_d value, that corresponds to the reduction in the total number of CX gates.

For eg, the Qiskit transpiler produces circuits with 28 CX gates on average , so our measurement becomes:

but by using the KAK decomposition method, we reduce the number of CX gates to 21 ,and produce

Then the approximation of SU(4) circuits further gains with the best result of

To understand how the quantum volume scales in a system with limited connectivity, as gate error probabilities decrease, we consider model circuits of width m on a square grid of m qubits. The m qubits are arranged into the largest possible square, and extra qubits are added first to a new right column and then to a new bottom row. We approximate the achievable model circuit depth ˜d(m) by assuming independent stochastic errors, so that the computation fails with high probability when the model circuit volume (width times depth) satisfies

Conclusion

The quantum volume is architecture-independent, and can be applied to any system that is capable of running quantum circuits. We conjecture that systems with higher connectivity will have higher quantum volume given otherwise similar performance parameters.

From numerical simulations for a given connectivity, we find that there are two possible paths for increasing the quantum volume. Although all operations must improve to increase the quantum volume, the first path is to prioritize improving the gate fidelity above other operations, such as measurement and initialization. The second path stems from the observation that, for these devices and this metric, circuit optimization is becoming important.