Benchmarking gate-based quantum computers

TL;DR

This paper proposes a benchmarking methodology for small gate-based quantum computers using simple, scalable quantum circuits that are sensitive to errors, demonstrated on IBM's cloud platform.

Contribution

It introduces a practical benchmarking approach using identity circuits that are easy to implement and effective for validating quantum processor performance.

Findings

Identity circuits effectively detect gate errors

Benchmarking method is scalable and simple to implement

Results demonstrated on IBM Quantum Experience

Abstract

With the advent of public access to small gate-based quantum processors, it becomes necessary to develop a benchmarking methodology such that independent researchers can validate the operation of these processors. We explore the usefulness of a number of simple quantum circuits as benchmarks for gate-based quantum computing devices and show that circuits performing identity operations are very simple, scalable and sensitive to gate errors and are therefore very well suited for this task. We illustrate the procedure by presenting benchmark results for the IBM Quantum Experience, a cloud-based platform for gate-based quantum computing.

Tables

Table 1. Table 4: List of measured 5-bit strings that correspond to the logical states | 0 ⟩ L subscript ket 0 𝐿 |0\rangle_{L} or | 1 ⟩ L subscript ket 1 𝐿 |1\rangle_{L} . Outcomes that correspond to neither of the logical states are omitted. Note that the order of the qubits differs from that chosen in Ref.  [ 14 ] .

${|0⟩}_L$	${|1⟩}_L$
$00000$	$00011$
$01111$	$01100$
$10110$	$10101$
$11001$	$11010$

Table 2. Table 1: Data of IBM-QE experiments with circuits which add two 2-bit numbers modulo 4 for the case that each pair of qubits encodes a single integer in the range 0 to 3. The first (second) group of results has been obtained with a circuit that uses qubits 0 – 3 (1 – 4). See A for more details on the circuits used. The experimental outcomes are colored according to the rule green: correct; red: wrong; magenta: unexpected (wrong) superposition; black: states with the next-to-highest relative frequency. The numbers in parentheses are the relative frequencies of occurrence.

Operation	Outcome	Outcome		Date
$|Q_0{Q}_1⟩+|Q_2{Q}_3⟩\to$	Quantum Theory	IBM-QE (8192 shots)
$|Q_3{Q}_2{Q}_0{Q}_1⟩$	$|\mathrm{state}⟩$  (prob.)	$|\mathrm{state}⟩$  (frequency)	$|\mathrm{state}⟩$  (frequency)
$2+1=3$	$|1_3{1}_2{1}_1{0}_0⟩$  (1.00)	$|1_3{1}_2{0}_1{1}_0⟩$  (0.275)	$|0_3{0}_2{0}_1{1}_0⟩$  (0.160)	22-Jan-17
$2+3=1$	$|0_3{1}_2{0}_1{1}_0⟩$  (1.00)	$|0_3{1}_2{0}_1{1}_0⟩$  (0.318)	$|0_3{1}_2{0}_1{0}_0⟩$  (0.150)	23-Jan-17
		$|0_3{0}_2{0}_1{1}_0⟩$  (0.271)	$|1_3{0}_2{0}_1{1}_0⟩$  (0.169)	30-Jan-17
		$|0_3{0}_2{0}_1{1}_0⟩$  (0.277)	$|1_3{0}_2{0}_1{1}_0⟩$  (0.172)	30-Jan-17
$1+3=0$	$|0_3{0}_2{1}_1{0}_0⟩$  (1.00)	$|0_3{0}_2{1}_1{0}_0⟩$  (0.343)	$|0_3{0}_2{0}_1{0}_0⟩$  (0.221)	30-Jan-17
$|Q_1{Q}_3⟩+|Q_2{Q}_4⟩\to$
$|Q_2{Q}_4{Q}_1{Q}_3⟩$
$2+1=3$	$|1_4{0}_3{1}_2{1}_1⟩$  (1.00)	$|1_4{0}_3{0}_2{1}_1⟩$  (0.342)	$|1_4{0}_3{1}_2{1}_1⟩$  (0.341)	25-Jan-17
		$|1_4{0}_3{1}_2{1}_1⟩$  (0.315)	$|0_4{0}_3{0}_2{1}_1⟩$  (0.165)	30-Jan-17
$2+3=1$	$|1_4{0}_3{0}_2{1}_1⟩$  (1.00)	$|1_4{0}_3{1}_2{1}_1⟩$  (0.225)	$|0_4{0}_3{0}_2{1}_1⟩$  (0.199)	30-Jan-17
		$|0_4{0}_3{0}_2{1}_1⟩$  (0.244)	$|1_4{0}_3{1}_2{1}_1⟩$  (0.210)	30-Jan-17
$1+3=0$	$|1_4{0}_3{0}_2{0}_1⟩$  (1.00)	$|1_4{0}_3{0}_2{0}_1⟩$  (0.493)	$|1_4{1}_3{0}_2{0}_1⟩$  (0.154)	30-Jan-17

Table 3. Table 2: Data of IBM-QE experiments with circuits which add two 2-bit numbers modulo 4 for the case in which the inputs are superpositions of two or four states. See A for an example of the circuit used. In all cases shown the IBM-QE yields the correct outcomes.

Operation	Outcome	Outcome	Date
$|Q_0{Q}_1⟩+|Q_2{Q}_3⟩\to |Q_3{Q}_2{Q}_0{Q}_1⟩$	Quantum Theory	IBM-QE (8192 shots)
Superposition of	$|\mathrm{state}⟩$  (prob.)	$|\mathrm{state}⟩$  (frequency)
$0+0=0$	$|0_3{0}_2{0}_1{0}_0⟩$  (0.50)	$|0_3{0}_2{0}_1{0}_0⟩$  (0.354)	17-Jan-17
$1+0=1$	$|0_3{1}_2{1}_1{0}_0⟩$  (0.50)	$|0_3{1}_2{1}_1{0}_0⟩$  (0.311)	17-Jan-17
$1+0=1$	$|0_3{1}_2{1}_1{0}_0⟩$  (0.50)	$|0_3{1}_2{1}_1{0}_0⟩$  (0.314)	17-Jan-17
$1+3=0$	$|0_3{0}_2{1}_1{0}_0⟩$  (0.50)	$|0_3{0}_2{1}_1{0}_0⟩$  (0.261)	17-Jan-17
$1+0=1$	$|0_3{1}_2{1}_1{0}_0⟩$  (0.25)	$|0_3{1}_2{1}_1{0}_0⟩$  (0.185)	17-Jan-17
$1+3=0$	$|1_3{1}_2{1}_1{1}_0⟩$  (0.25)	$|1_3{1}_2{1}_1{1}_0⟩$  (0.152)	17-Jan-17
$3+0=3$	$|0_3{0}_2{1}_1{0}_0⟩$  (0.25)	$|0_3{0}_2{1}_1{0}_0⟩$  (0.147)	17-Jan-17
$3+3=2$	$|1_3{0}_2{1}_1{0}_0⟩$  (0.25)	$|1_3{0}_2{1}_1{0}_0⟩$  (0.097)	17-Jan-17

Table 4. Table 3: Data for experiments with identity operations, generated by the IBM-QE. See A for more details on the circuits used. Green (red)-colored states indicate experimental outcomes that, according to the rule (see section  2 ) used, are (not) the same as the theoretically expected state. The states in the experimental outcomes with the next-to-highest relative frequency are given in black. The numbers in parentheses are the relative frequencies of occurrence. Each calculation has been repeated several times, on the dates indicated.

Operation	Input	Outcome	Outcome		Date
		Quantum Theory	IBM-QE (8192 shots)
		$|\mathrm{state}⟩$  (prob.)	$|\mathrm{state}⟩$  (frequency)	$|\mathrm{state}⟩$  (frequency)
${\left(C_{01}\right)}^8$	$|0_1{0}_0⟩$	$|0_1{0}_0⟩$  (1.00)	$|0_1{0}_0⟩$  (0.661)	$|1_1{0}_0⟩$  (0.299)	16-Jan-17
			$|0_1{0}_0⟩$  (0.700)	$|1_1{0}_0⟩$  (0.198)	18-Jan-17
			$|0_1{0}_0⟩$  (0.642)	$|1_1{0}_0⟩$  (0.289)	19-Jan-17
			$|0_1{0}_0⟩$  (0.580)	$|1_1{0}_0⟩$  (0.335)	23-Jan-17
			$|0_1{0}_0⟩$  (0.628)	$|1_1{0}_0⟩$  (0.256)	23-Jan-17
${\left(C_{34}\right)}^8$	$|0_4{0}_3⟩$	$|0_4{0}_3⟩$  (1.00)	$|1_4{0}_3⟩$  (0.512)	$|0_4{0}_3⟩$  (0.372)	15-Jan-17
			$|1_4{0}_3⟩$  (0.567)	$|0_4{0}_3⟩$  (0.318)	16-Jan-17
			$|1_4{0}_3⟩$  (0.548)	$|0_4{0}_3⟩$  (0.363)	18-Jan-17
			$|1_4{0}_3⟩$  (0.616)	$|0_4{0}_3⟩$  (0.275)	19-Jan-17
			$|1_4{0}_3⟩$  (0.590)	$|0_4{0}_3⟩$  (0.323)	22-Jan-17
			$|1_4{0}_3⟩$  (0.618)	$|0_4{0}_3⟩$  (0.321)	23-Jan-17
${\left(C_{34}\right)}^8$	$|0_4{1}_3⟩$	$|0_4{1}_3⟩$  (1.00)	$|0_4{1}_3⟩$  (0.794)	$|0_4{0}_3⟩$  (0.084)	15-Jan-17
			$|0_4{1}_3⟩$  (0.797)	$|0_4{0}_3⟩$  (0.088)	18-Jan-17
			$|0_4{1}_3⟩$  (0.853)	$|0_4{0}_3⟩$  (0.077)	23-Jan-17
			$|0_4{1}_3⟩$  (0.849)	$|0_4{0}_3⟩$  (0.068)	23-Jan-17
${\left(C_{02}{C}_{12}\right)}^2{\left(C_{02}\right)}^2{\left(C_{12}\right)}^2$	$|1_2{1}_1{1}_0⟩$	$|1_2{1}_1{1}_0⟩$  (1.00)	$|1_2{1}_1{1}_0⟩$  (0.355)	$|1_2{1}_1{0}_0⟩$  (0.304)	10-Jan-17
${\left(C_{02}{C}_{12}\right)}^2$			$|0_2{1}_1{1}_0⟩$  (0.262)	$|1_2{1}_1{1}_0⟩$  (0.238)	18-Jan-17
			$|0_2{1}_1{1}_0⟩$  (0.250)	$|1_2{1}_1{1}_0⟩$  (0.237)	18-Jan-17
			$|0_2{1}_1{1}_0⟩$  (0.358)	$|1_2{1}_1{1}_0⟩$  (0.131)	27-Jan-17
			$|0_2{1}_1{1}_0⟩$  (0.368)	$|1_2{1}_1{1}_0⟩$  (0.128)	27-Jan-17
			$|0_2{1}_1{1}_0⟩$  (0.347)	$|1_2{1}_1{1}_0⟩$  (0.139)	27-Jan-17
			$|0_2{1}_1{1}_0⟩$  (0.374)	$|1_2{1}_1{1}_0⟩$  (0.150)	27-Jan-17
$H_0{H}_1{X}_0{X}_1{\left(C_{02}{C}_{12}\right)}^2$	$|1_2{1}_1{1}_0⟩$	$|1_2{1}_1{1}_0⟩$  (1.00)	$|1_2{1}_1{1}_0⟩$  (0.304)	$|0_2{1}_1{1}_0⟩$  (0.157)	05-May-16
${\left(C_{02}\right)}^2{\left(C_{12}\right)}^2$			$|1_2{1}_1{1}_0⟩$  (0.298)	$|0_2{1}_1{1}_0⟩$  (0.192)	09-Nov-16
${\left(C_{02}{C}_{12}\right)}^2{H}_0{H}_1$			$|1_2{1}_1{1}_0⟩$  (0.223)	$|0_2{1}_1{1}_0⟩$  (0.156)	20-Nov-16
			$|0_2{1}_1{1}_0⟩$  (0.232)	$|0_2{0}_1{0}_0⟩$  (0.154)	27-Jan-17
			$|0_2{1}_1{1}_0⟩$  (0.202)	$|0_2{0}_1{0}_0⟩$  (0.170)	27-Jan-17

Equations

$$|\Psi ⟩$$

$$⟨\Psi |{\mathbf{\sigma }}_1\cdot \mathbf{a}|\Psi ⟩$$

$$E(\mathbf{a},\mathbf{b})$$

$$P(S_1,S_2|\mathbf{ab})$$

$$\sum _{S_1=\pm 1}\sum _{S_2=\pm 1}P(S_1,S_2|\mathbf{ab})$$

$$\sum _{S_1=\pm 1}\sum _{S_2=\pm 1}{S}_{1}P(S_1,S_2|\mathbf{ab})$$

$$\sum _{S_1=\pm 1}\sum _{S_2=\pm 1}{S}_{2}P(S_1,S_2|\mathbf{ab})$$

$$\sum _{S_1=\pm 1}\sum _{S_2=\pm 1}{S}_1{S}_{2}P(S_1,S_2|\mathbf{ab})$$

$$P(S_1,S_2|\mathbf{ab})$$

$$P_{\mathrm{singlet}}(S_1,S_2|\mathbf{ab})$$

$$P(q_1,q_2|\mathbf{ab})$$

$$|{\Phi }_{\mathrm{data}}⟩$$

$$|0{⟩}_L$$

$$|1{⟩}_L$$

$$C{Z}_{ij}$$

$$C-Z_{ij}$$

$$C{Y}_{ij}$$

Full text

††journal: Computer Physics Communications

1 Introduction

As small gate-based quantum computer hardware is being made available to the public [1, 2], it is now possible for independent parties to validate and benchmark the operation of these devices. Therefore, it seems natural to introduce a suite of quantum algorithms (i.e. sequences of gate operations [3]) which should be used to validate quantum processors. The aim of this paper is to explore the potential of several different, simple sequences of gate operations that can be used for this task, building on earlier work that was specifically targeting NMR quantum processors [4].

A gate-based quantum computer is a device that takes input data and transforms this input data according to a unitary operation, specified as a sequence of gate operations and measurements (i.e. the algorithm) and conveniently represented by a quantum circuit [3]. The algorithm itself does not depend on the input data and returns the result of the transformation in the form of output data. If the transformation involves random processes, the output data have to be interpreted according to the probabilistic model (i.e. quantum theory in the case of a quantum computer) of these random processes. Evidently, this cursory description of a gate-based quantum computer refers to the highly abstract mathematical model of the device only.

The central question is to what extent the hardware implementation of a quantum processor operates according to the mathematical model and can therefore deliver the exponential speed-up that this mathematical model promises [3]. Although one can think of many physical processes that cause the hardware implementation to function in a way that differs from the one imagined on the basis of its circuit model [3], from a user perspective (but not from the perspective of the manufacturer), it is immaterial whether a malfunctioning of the device can be attributed to a particular physical process or not. The only thing that matters is whether the device performs the desired computation properly.

For a device that performs the mapping “algorithm(input data) $\rightarrow$ output data” to qualify as a computer, the following two requirements seem essential:

For each instance of the input data and with the algorithm fixed, the relation algorithm(input data) $\rightarrow$ output data should yield (within statistical fluctuations) the correct output data. In the case of a gate-based quantum computer, the correct output data can be obtained by running the algorithm on the mathematically exact, pen-and-paper-model of the quantum computer. For this purpose, one can use a massively parallel quantum computer simulator [5, 6] running on PC’s or supercomputers such as JUQUEEN [7] (an IBM Blue Gene/Q) or the K computer, allowing the simulation of up to 45 qubits (on the K computer). If the number of qubits does not exceed 5 it is more convenient to execute the algorithm on the simulator included in the IBM Quantum Experience (IBM-QE) [2].

• 2.

For the same input data and with the algorithm fixed, the output data should be stationary in time. Disregarding statistical fluctuations, this means that the output data should not change with the time or day when the procedure is carried out.

In this paper, we strictly take the viewpoint of a potential user of a quantum processor, that is we explore the use of simple but decisive gate sequences to check if the hardware implementation of a quantum processor complies with the two aforementioned requirements for being a useful computing device. We illustrate the procedure by running these tests on the IBM-QE [2] and demonstrate that this device does not qualify accordingly. We assume that the reader has some elementary notion of what quantum computation is about but again, from the viewpoint of a user such knowledge is not required to properly interpret the results of the tests that we present.

The paper is organized as follows. In section 2, we give a brief overview of the IBM-QE hardware, confining ourselves to those aspects that are relevant for the user who wants to run applications on the processor. We also discuss the procedure of collecting and analyzing the experimental data. Section 3 presents results for a very simple but instructive application, the preparation and subsequent measurement of the singlet state. Section 4 explores the potential of using a two-register adder as a check on the hardware. The corresponding quantum circuit [8] involves the quantum Fourier transform [3] and performs addition modulo 4. The adder circuit has the appealing feature that it is trivial to check whether or not the hardware does the addition correctly. Moreover, as it requires significantly more gate operations than the circuit employed in section 3, it may be expected to be more prone to the accumulation of errors. Section 5 introduces a very simple, flexible and scalable class of quantum circuits that prove to be well-suited for validating quantum processors. The key is to perform identity operations or, in other words, no operation at all. Within the mathematical model of the quantum processor, each gate operation corresponds to a unitary transformation on the qubits and hence it is almost trivial to construct sequences of identity operations. Also in this case, it is easy to decide whether the processor functions properly or not. In section 6, we scrutinize the usefulness of two different error correction schemes and show that in practice, meaning on the IBM-QE hardware, these schemes do not live up to the expectations, namely instead of reducing they enhance the chance for an incorrect result. Section 7 contains a discussion of the conclusions that we draw on the basis of the experimental data.

2 The IBM quantum experience

Since May 2016 IBM has been providing public access to a 5-qubit quantum processor [2]. The first version of this processor allowed for single-qubit operations on all qubits and CNOT operations between 4 qubits (numbered 0,1,3,4) and the qubit number 2, i.e. between the qubit pairs (0,2), (1,2), (3,2), and (4,2) where the first element of the pairs denotes the control qubit. The present version allows for additional CNOT operations, namely between the pairs (0,1) and (3,4). The device is accessible through a web interface which provides the necessary tools to execute quantum programs on the device, as well as on a simulator that performs the operations according to the mathematical model of the idealized device.

An experiment on the IBM-QE consists of (i) specifying the quantum circuit, either through a graphical interface or a text-based editor, (ii) running the circuit on the simulator to check if the circuit has been specified correctly, and (iii) executing the circuit on the hardware processor for a number $N$ of so-called “shots”. With each shot, the processor is first initialized and is then instructed (by a controller not accessible to the user) to execute the quantum circuit.

Barriers prevent software optimization of successive gates in a circuit [2]. As this optimization was turned off at the time we did our experiments, there was no need to include barriers in our circuits. However, to make sure that the IBM-QE software does not optimize the circuit, we recommend including barriers in future experiments.

The final state of the device is read out by a process called “measurement” which, for each shot, returns either the values 0 or 1 for each of the measured qubits. Thus, each shot yields one string of at most 5 bits which may or may not be different each time the circuit is executed. After $N$ shots, the system returns the counts of the number of times that each of the different bit strings was generated. These counts, not the individual bit strings, constitute the result of executing the quantum algorithm.

2.1 Device characteristics

According to the IBM-QE documentation and private communication with the IBM-QE team, execution of an X, Hadamard, and CNOT gate takes $130\;$ns, $130\;$ns, and $650\;$ns, respectively. The coherence time of a single qubit is of the order of $100\;\mu\mathrm{s}$. The gate errors, estimated from randomized benchmarking [9], are in the range $10^{-2}$ – $10^{-3}$. These are parameters of the device that was in use between January 11, 2017 and February 6, 2017. These numbers vary somewhat from one device calibration to another (typically twice a day).

2.2 Data analysis

Each run of an algorithm on the IBM-QE yields a definite pattern of (five) output bits (0 or 1). This pattern, a basis state in quantum theory parlance, is interpreted as being the result of measuring the quantum state of the machine. We denote a basis state of the IBM-QE by $|Q_{4}Q_{3}Q_{2}Q_{1}Q_{0}\rangle$ where the Q’s are either 0 or 1, and we use a similar notation for less than 5 qubits. The subscripts correspond to the labels of the qubits of the IBM-QE and are necessary because some algorithms might permute logical and physical qubits, as in the case of the adder and the error correction algorithm discussed below.

In this paper, we present results of repeating the procedure of executing the algorithm and measuring the state of the device $N=8192$ times, the maximum number of shots currently allowed. The counts of the different configurations of 0’s and 1’s divided by the number of shots give us the relative frequencies (rational numbers between 0 and 1, with their sum being equal to one) with which the basis states are observed.

In this paper, we take as the “correct” result of the computation either the collection of states with the largest relative frequencies or the state that appears with the largest relative frequency if a unique answer is expected.

If quantum theory is assumed to describe the operation of the device, each measurement constitutes a statistically independent trial [10]. Within statistical fluctuations, the measured frequencies to observe the system in one of the basis states should correspond to the probabilities predicted by quantum theory [10]. Let us denote by $x_{n}=1(0)$ the fact that a particular basis state is (not) observed in trial $n=1,\ldots,N$. The relative frequency is then $f=N^{-1}\sum_{n=1}^{N}x_{n}$. Assuming that the $x_{n}$ are identically distributed random variables, the standard error (SE) on the estimated value of $f$ is bounded by $1/\sqrt{N}$. For the case at hand, we conclude that if the measurements constitute identically distributed random trials, the standard error on the data that we present in this paper (with $N=8192$) does not exceed $\mathrm{SE}=0.012$. Frequencies that are within five standard errors ($5\;\mathrm{SE}=0.06$) are considered to be the same.

It is to be expected that the results obtained by executing a quantum circuit not only suffer from statistical errors but, as shown below, also from other errors that are much harder to characterize properly. Let us assume that for each gate operation, there is a probability $0<p_{\mathrm{C}}<1$ that the result of the operation, if measured, is correct and that the probability for a sequence of $m$ identical gates to return the correct answer is $p_{\mathrm{C}}^{m}$. For instance, taking $p_{\mathrm{C}}=0.95$, this error model would predict a sequence of $m=20$ gates to produce the correct result with a probability of about 0.36, which is larger than the probability for sampling (uniformly) at random if the number of qubits is larger than one. Our experiments strongly suggest that the variations in the experimental results presented below are much larger and cannot be explained by probabilistic error models based on the single-gate errors, often estimated from randomized benchmarking [11], supporting the viewpoint that the estimates obtained by the latter have some deficiencies [12].

3 Entanglement

A conceptually simple experiment to test whether a two-qubit system is capable of exhibiting quantum behavior is to repeatedly prepare the device such that the readout of its internal state yields a frequency distribution of events that agrees with the probability distribution of two spin-1/2 particles in the singlet state, a maximally entangled state [10]. Note that the observation that the frequency distribution of many events agrees with the probability distribution of the singlet state is only a post-factum characterization of the repeated preparation and measurement process, not a demonstration that at the end of the preparation stage, the device actually is in the singlet state. The latter describes the statistics, not the internal state at any particular instance [10].

The singlet state is defined by

[TABLE]

The averages of (combinations of) Pauli spin matrices $\bm{\sigma}=(\sigma^{x},\sigma^{y},\sigma^{z})$ are

[TABLE]

where $\mathbf{a}$ and $\mathbf{b}$ are three-dimensional unit vectors and $\theta$ is the angle between these two vectors.

It is not difficult to see that in general, any function $P(S_{1},S_{2}|\mathbf{a}\mathbf{b})$ of the two-valued variables $S_{1},S_{2}=\pm 1$ can be written as

[TABLE]

simply because

[TABLE]

If $P(S_{1},S_{2}|\mathbf{a}\mathbf{b})$ is to represent the probability that a measurement of the spins $(\bm{\sigma}_{1}\cdot\mathbf{a},\bm{\sigma}_{2}\cdot\mathbf{b})$ yields the values $(S_{1},S_{2})$, we must have $P_{0}=1$ and therefore

[TABLE]

with certain restrictions on $(P_{1},P_{2},P_{3})$ because we must also have $0\leq P(S_{1},S_{2}|\mathbf{a}\mathbf{b})\leq 1$ for $P(S_{1},S_{2}|\mathbf{a}\mathbf{b})$ to qualify as a probability.

We find the probability for measuring the spins $(S_{1},S_{2})$ in the singlet state by combining Eqs. (2), (3) and (6), meaning that we set $P_{1}=\langle\Psi|\bm{\sigma}_{1}\cdot\mathbf{a}|\Psi\rangle=0$, $P_{2}=\langle\Psi|\bm{\sigma}_{2}\cdot\mathbf{b}|\Psi\rangle=0$, $P_{3}=\langle\Psi|\bm{\sigma}_{1}\cdot\mathbf{a}\;\bm{\sigma}_{2}\cdot\mathbf{b}|\Psi\rangle=-\mathbf{a}\cdot\mathbf{b}$ and obtain

[TABLE]

The mapping from the spin-1/2 eigenvalues $S_{i}=+1,-1$ to the qubit values $q_{i}=0,1$ is given by $q_{i}=(1-S_{i})/2$ (or $S_{i}=1-2q_{i}$) for $i=1,2$ [3]. Therefore, according to quantum theory, the probability that a measurement of the qubits $(Q_{1},Q_{2})$ yields the values $(q_{1},q_{2})$ ($q_{1},q_{2}=0,1$), is given by

[TABLE]

The quantum circuit generating the singlet state is very simple: assuming that the initial state of the two qubits is $|0_{2}0_{1}\rangle$, perform an X operation on qubits 1 and 2 to change the state to $|1_{2}1_{1}\rangle$, apply a Hadamard gate on qubit 1, and execute a CNOT operation with qubit 1 (2) as control (target) qubit. In our experiments, we have chosen $\mathbf{a}=(0,-\sin\theta_{1},\cos\theta_{1})$ and $\mathbf{b}=(0,-\sin\theta_{2},\cos\theta_{2})$ such that $\mathbf{a}\cdot\mathbf{b}=\cos(\theta_{1}-\theta_{2})$. The circuit that, in the ideal case, generates $(q_{1},q_{2})$ according to Eq. (8) and implements the measurement in a rotated basis specified by $\mathbf{a}$ and $\mathbf{b}$, then consists of two X-gates, five Hadamard gates, one $U_{1}(\theta_{1})$ and one $U_{1}(\theta_{2})$ gate, and a CNOT gate. The sequence of gates that implements this circuit is given in A.

Executing the sequence of gates on the IBM-QE yields, after $N=8192$ shots, the relative frequencies $f(q_{1},q_{2})$ ($f(0,0)+f(0,1)+f(1,0)+f(1,1)=1$) with which the pair $(q_{1},q_{2})$ is generated. The averages and correlation of the Pauli spin matrices projected onto the directions of measurement are given by $F_{1}(\theta_{1},\theta_{2})=f(0,0)+f(0,1)-f(1,0)-f(1,1)$, $F_{2}(\theta_{1},\theta_{2})=f(0,0)-f(0,1)+f(1,0)-f(1,1)$, and $F(\theta_{1},\theta_{2})=f(0,0)-f(0,1)-f(1,0)+f(1,1)$, respectively.

For a two-qubit system, the averages of the Pauli-spin matrices are $E_{1}(\theta_{1})=\langle\Psi|\bm{\sigma}_{1}\cdot\mathbf{a}|\Psi\rangle$, $E_{2}(\theta_{2})=\langle\Psi|\bm{\sigma}_{2}\cdot\mathbf{b}|\Psi\rangle$, and $E(\theta_{1},\theta_{2})=\langle\Psi|\bm{\sigma}_{1}\cdot\mathbf{a}\;\bm{\sigma}_{2}\cdot\mathbf{b}|\Psi\rangle=-\mathbf{a}\cdot\mathbf{b}$. Therefore, if the operation of the IBM-QE is described by the quantum theory of a system of qubits, we expect to find that $F_{1}(\theta_{1},\theta_{2})\approx E_{1}(\theta_{1})$, $F_{2}(\theta_{1},\theta_{2})\approx E_{2}(\theta_{2})$, and $F(\theta_{1},\theta_{2})\approx E(\theta_{1},\theta_{2})$.

In Fig. 1, we present experimental data as obtained by executing the sequence of gates on the IBM-QE. Qualitatively, the data presented in Fig. 1 show the features that are expected from the quantum theoretical description in terms of the singlet state but quantitatively, there are significant deviations. For $\mathbf{a}=\mathbf{b}=(0,-\sin\theta_{1},\cos\theta_{1})$ quantum theory predicts that $\langle\Psi|\bm{\sigma}_{1}\cdot\mathbf{a}\;\bm{\sigma}_{2}\cdot\mathbf{b}|\Psi\rangle$ is constant in the range $[0.945,1]$ whereas the experiment (see Fig. 1 (right)) gives $F(\theta_{1},\theta_{1})\approx 0.80$, far outside the expected interval. The single-qubit averages $F_{1}(\theta_{1},\theta_{1})$ and $F_{2}(\theta_{1},\theta_{1})$ are zero within a 6 SE margin. Assuming that the data is described by quantum theory in terms of a pure state, a nonlinear fit to all the data presented in Fig. 1 yields

[TABLE]

It is noteworthy that the mentioned artifacts are not only found in the data produced by the IBM-QE experiments but are also present in data collected in Einstein-Podolsky-Rosen-Bohm experiments with photons [13]. From a more general perspective, it is instructive to compare the “accuracy” of the results produced by quantum physics experiments such as those (but not only those) performed on the IBM-QE with those on e.g. atomic systems. The accuracy by which quantum theory predicts, say, the ratios of the wavelengths of the Balmer absorption/emission lines of hydrogen is about 4 digits. Some of the wavelengths of these lines have been measured with roughly this precision in the beginning of the previous century with, for present-day standards, pre-historic equipment. Taking the experiments on entanglement, which involve only a few gate operations, as an example, experiments (not only the IBM-QE but also experiments with photons, neutrons, ions, …) reproduce the quantum-theoretical prediction for the correlation $\langle\Psi|\bm{\sigma}_{1}\cdot\mathbf{a}\;\bm{\sigma}_{2}\cdot\mathbf{a}|\Psi\rangle=-1$ with an accuracy of not more than 2 digits. Apparently, it seems rather challenging for humans to engineer devices that operate according to the laws of quantum theory with a precision akin to that of atomic systems found in nature.

4 Two-qubit + two-qubit adder

A rather simple but nontrivial algorithm to test the correctness of quantum computer simulation software and hence also devices is to perform integer addition, which has the appealing feature that it is trivial to check the correctness of the results generated by the software or device [5]. The algorithm that we use here makes use of a quantum Fourier transform [8]. Due to the limitations of the IBM-QE hardware, the integers that can be added are rather small ($\leq 3$). Nevertheless, running the algorithm on the IBM-QE reveals some interesting behavior, also see the supplementary material of Ref. [14]. The implementation of the adder circuit is different from the one reported in Ref. [14]. It has been validated by running the quantum algorithm on the simulator and comparing the results with those of integer arithmetic modulo 4.

In Table LABEL:tab2a, we collect a number of cases for which the IBM-QE results are sometimes correct and sometimes wrong. We have not been able to detect any systematics in this behavior. QE results that are correct on a particular day may turn out wrong on another date, or vice versa. See also Ref. [14].

In Table LABEL:tab2b, we present some data for the case that the inputs are superpositions of the states that represent the integer numbers. In all cases shown, execution of the algorithm on the IBM-QE returns the expected answer.

5 Identity operations

Sequences of several CNOT operations provide simple but decisive test cases [4]. Theoretically, each pair of CNOT gates acts as an identity operation, hence, if the number of CNOT operations is even, we expect to see that the output state is the same as the input state. In Table LABEL:tab1, we present some representative results for sequences of 8 and 12 CNOT gates. Some of these sequences are preceeded/followed by some X and H gates to change the input/output to/of the sequence of CNOTs. The duration of 12 successive CNOT gates ($\approx 8\;\mu\mathrm{s}$) is well within the coherence time of the qubits ($100\;\mu\mathrm{s}$).

From Table LABEL:tab1 it is clear that, except for the cases shown in the last two rows, the states that occur with the largest relative frequency are quite robust: they do not change if we repeat the experiment. Moreover, all relative frequencies are in the same ball park and fairly large. However, comparing the data of the second and third row, we must conclude that there is no guarantee that the device is operating properly. Obviously, the operation of the device suffers from errors which are hard to gauge. We have found no systematic procedure to determine the conditions under which the device produces blatantly wrong results.

6 Error correction

The idea of quantum error correction is to introduce redundancy by using $m$ physical qubits to encode $k<m$ logical qubits such that the information is effectively protected against decoherence [15]. Quantum error-correcting codes are commonly denoted by $[[m,k,d]]$, where the distance $d$ includes information about the number of errors the code can correct [3]. Since the IBM-QE supports five qubits, small codes using $m\leq 5$ physical qubits can be implemented and tested (see also Refs. [14] and [16]).

We study two different five-qubit codes. The first is a particular distance-two surface code already analyzed by Devitt using a previous version of the IBM-QE [14]. The second is an instance of the perfect $[[5,1,3]]$ code introduced in Refs. [17] and [18].

6.1 Distance-two surface code

Surface codes are considered to be among the most promising error-correction schemes as they can cope with error rates of about $10^{-2}$ [19]. The distance-two surface code $[[5,1,2]]$ studied in Ref. [14] employs postselection to discard outcomes which are not included in the code space. In other words, the set of 5-bit strings resulting from the $N=8192$ shots are first analyzed and then the results are corrected.

In our first test of the distance-two surface code, we employ the same encoding circuit as described by Devitt [14]. This circuit is shown in Fig. 2 and starts right after the last of the three $T$-gates. In our test procedure, the chosen number of $T$-gates ranges from 0 to 8, eventually resulting in a rotation of the state $|0\rangle$ to $|1\rangle$ and back to $|0\rangle$. For comparison, we also perform the same test without quantum error correction. As an example, we show the corresponding circuit with three $T$-gates in Fig. 3.

In our second test, we use the same encoding circuit as in the first test, followed by $K=0,\ldots,8$ logical $X$-gates. In contrast to our first test, the state $|0\rangle$ is first encoded into the logical state $|0\rangle_{L}$ and then the logical-$X$ operator is applied $K$ times before the measurements in the $z$-basis are performed. For comparison, the same experiment is repeated using a single qubit without the quantum error correction.

Postselection is done according to Table 4, that is we only count the outcomes that correspond to a measurement of one of the logical states $|0\rangle_{L}$ or $|1\rangle_{L}$. In our experiments, about three quarters of the shots are discarded by the postselection process.

The results of the first test are shown in Fig. 4 (left). Stars correspond to the output of the simulator which operates as an ideal quantum computer and therefore provides a stringent test of the correctness of the circuit itself. The outcomes lie on the solid line which represents the sinusoidal function predicted by quantum theory. The results from the single-qubit circuit (open circles) qualitatively follow the expected curve but with a reduced visibility. For the encoded qubit, postselection reduces the number of valid shots from 8192 to 2000 – 2300, i.e., there are about 2000 5-bit strings that correspond either to a logical 0 or a logical 1. After postselection, the results of the encoded qubit (open squares) are worse than for the single qubit, with deviations from the exact result that are far outside the range of the statistical fluctuations. However, a potential problem of this first test is that the rotation is done on the single qubit before it is encoded. Hence errors that occur during the rotation cannot be detected by the error-correction code.

In our second test, see Fig. 4 (right), the rotation is thus performed after the encoding but the results are essentially the same: the encoding procedure induces more errors than can be detected. Indeed, the single qubit results (stars) are much closer to the ideal outcome (one for an even number of $X$-gates and zero for an odd number of $X$-gates) when no error-correcting code is used than those obtained with the use of error-correction. The results for the encoded qubit (open circles for an even number of $X$-gates and open squares for an odd number) are only slightly better than just randomly picking zeros or ones. At least, the frequencies of the quantum error-corrected qubits do not change a lot with the number of $X$-gates applied.

6.2 Distance-three 5-qubit code

The distance-three 5-qubit code $[[5,1,3]]$ is called a perfect quantum error-correcting code since it is the smallest code that, theoretically, has the ability to correct any single-qubit error [17]. From the different presentations of this code (see Ref. [18]), we choose the one given in Refs. [3] and [20] where the logical states are defined as

[TABLE]

The encoding circuit for this code is given in Ref. [20]. As the IBM-QE does not support the controlled $Z$ ($CZ$), controlled $-Z$ ($C\!-\!Z$), and controlled $Y$ ($CY$) gates, we rewrite the circuit in terms of the CNOT gate ($C$) and other single-qubit gates that the IBM-QE supports by using the circuit identities

[TABLE]

Applying the relation $SZ=S^{\dagger}$ and swapping the lines of $Q_{0}$ and $Q_{2}$, we thus arrive at the encoding circuit shown in Fig. 5, whose purpose is to encode the state $|00Q_{2}00\rangle\mapsto|Q_{2}\rangle_{L}$. Due to the reduced connectivity of the IBM-QE, we further express all unsupported CNOT gates $C_{ij}$ in terms of $C_{i2}$ and $C_{j2}$ using the identity $C_{ij}=H_{i}H_{j}C_{ji}H_{i}H_{j}$ and the SWAP gate $\mathrm{SWAP}_{ij}=C_{ij}C_{ji}C_{ij}$. The listing of the full circuit is given in A and takes about $33\;\mu\mathrm{s}$ to run to completion.

The correctness of the encoding circuit is established by running the ciruit on the ideal quantum computer simulator (included in the IBM-QE). The results are shown in the left panel of Fig. 6. From the top-left panel, it is clear that starting from the state $|Q_{2}=0\rangle$, the circuit produces a uniform superposition of all the basis states (solid bars) contained in the codeword $|0\rangle_{L}$ (see Eq. (10)). Similarly, the bottom-left panel shows that encoding the state $|Q_{2}=1\rangle$ properly yields the codeword $|1\rangle_{L}$ (hatched bars) given by Eq. (11). Note that the height of the bars differs slightly from $1/16$ due to the random sampling used in the $N=8192$ shots.

The results of running the same circuit on the real chip are depicted in the right panel of Fig. 6. We repeated each experiment of $N=8192$ shots five times to get some information about the reproducibility and the statistical distribution of the results. In the right panel of Fig. 6, the corresponding standard deviations are indicated by error bars.

The results clearly demonstrate that, apart from statistical fluctuations, the real processor produces the same output irrespective of whether the initial state was $|Q_{2}=0\rangle$ (solid bars) or $|Q_{2}=1\rangle$ (hatched bars). The outcome is completely different from the one obtained with the simulator (compare with left panel of Fig. 6). For each case, the resulting distribution contains in a pair-wise manner almost equally important contributions from the other case. This makes it impossible for the user to distinguish the logical state $|0\rangle_{L}$ from the logical state $|1\rangle_{L}$. Therefore, we have to conclude that the IBM-QE fails to generate the correct outcome for the encoding part of the perfect distance-three 5-qubit code. Unfortunately, because the number of gates that is allowed on the IBM-QE is limited to 80, we cannot carry out the corresponding decoding circuit.

7 Discussion

We have explored the use of four classes of quantum circuits to benchmark quantum computer hardware by executing these circuits on the only gate-based quantum computer that is publicly accessible today. The class of identity operations built from CNOT gates stands out in terms of simplicity, scalability, and sensitivity to malfunctioning hardware. We propose that apart from characterizing the operation of the individual qubits, and as a minimal benchmark, any system that performs quantum computation is subjected to this class of circuits. Some of these circuits might also be useful for the calibration procedure itself.

From the results presented in the foregoing sections, we draw the following conclusions:

For some systems of two and four qubits, qualitative agreement with quantum theory was observed.

• 2.

Errors could not be identified by the user nor be corrected using quantum error-correction, and could not be attributed to the specified gate errors.

• 3.

The data showed strong variations between calibrations.

• 4.

Sequences of identity operations provide simple, scalable algorithms to validate the correct operation of the device [4].

• 5.

The current IBM-QE device does not meet the two elementary requirements (see section 1) for a computing device.

• 6.

The IBM-QE allows a theoretician to perform real laboratory experiments.

From the perspective of a user, the IBM-QE does not perform as could reasonably be expected from a computer. Except for very simple circuits which return qualitatively correct results, the IBM-QE device often fails to return the correct results for reasons which in some cases may be traced back to running the algorithm on a different day (with a different device calibration) but in other cases do not seem to have a simple explanation. Needless to say, it would be of great interest to have the simple benchmarks carried out on other hardware platforms, in particular on the recent 5-qubit ion-trap device [21], and see how they perform relative to the IBM-QE.

One fairly simple reason for the failure of the IBM-QE to function as a computer may be that the two-state model used to describe the qubits does not capture, not even approximately, the time evolution of the system of coupled transmons [22]. Indeed, preliminary simulations based on a more comprehensive model of transmons indicate that their time evolution fundamentally involves more than two energy levels. This then raises the question whether the failures observed in our IBM-QE experiments can be traced back to the limited usefulness of the two-state description. This question can readily be addressed by solving the time-dependent Schrödinger equation for more realistic models of coupled transmons and we intend to carry out such simulations in the near future.

Acknowledgements

We are grateful to the IBM Quantum Experience project team for sharing technical details with us. This work does not reflect the views or opinions of IBM or any of its employees.

[FIGURE:]

[FIGURE:]

[FIGURE:]

Appendix A Algorithms in QASM language

For completeness, we give the .qasm files of the quantum-gate circuits used to perform the experiments reported on in this paper. For a detailed description of the programming language see Ref. [2].

A.1 Singlet state

A.2 Adder using qubits 0 – 3

A.3 Adder using qubits 1 – 4

A.4 Identity operation

A.5 Error correction: distance-two surface code

A.6 Error correction: distance-three 5-qubit code