Implementation of single-qubit measurement-based t-designs using IBM processors.

Random unitary matrices sampled from the uniform Haar ensemble have a number of important applications both in cryptography and in the simulation of a variety of fundamental physical systems. Since the Haar ensemble is very expensive to sample, pseudorandom ensembles in the form of t-designs are frequently used as an efficient substitute, and are sufficient for most applications. We investigate t-designs generated using a measurement-based approach on superconducting quantum computers. In particular, we implemented an exact single-qubit 3-design on IBM quantum processors by performing measurements on a 6-qubit graph state. By analysing channel tomography results, we were able to show that the ensemble of unitaries realised was a 1-design, but not a 2-design or a 3-design under the test conditions set, which we show to be a result of depolarising noise during the measurement-based process. We obtained improved results for the 2-design test by implementing an approximate 2-design, in which measurements were performed on a smaller 5-qubit graph state, but the test still did not pass for all states. This suggests that the practical realisation of measurement-based t-designs on superconducting quantum computers will require further work on the reduction of depolarising noise in these devices.

Introduction

Random unitary matrices have a number of important applications, which include estimating noise[1], realising private channels[2], modeling thermalisation[3] and formulating quantum mechanical models of black holes[4]. However, the generation of uniformly distributed random unitaries is very resource intensive, since the resources required to sample randomly with respect to the Haar measure on , the group of unitary transformations on a n-qubit system, scale exponentially with n[5]. A t-design is a pseudorandom ensemble of which the statistical moments match those of the uniform Haar ensemble up to some finite order t. Hence, a t-design is by definition a -design. These t-designs can rarely be distinguished from the true random ensemble, and so they are often used as a substitute. Even approximate t-designs are sufficient for many applications, for example approximate 1-designs can be used for encrypting quantum data[6], approximate 2-designs can be used for estimating channel fidelities[7] and approximate 3-designs can be used for solving black-box problems[8].

In random circuit constructions, t-designs on n qubits are realised by applying gates selected randomly from a universal set to qubits from a n-qubit system. Approximate n-qubit t-designs can be realised efficiently, since the resources required (the number of gates and random bits) scale polynomially with n and t[9-12]. Very efficient random circuit constructions for exact n-qubit 2-designs, where the resources required scale almost linearly with n, have also been devised[13]. More recently, random circuit constructions for general exact n-qubit t-designs were proposed[14]. However, they are only feasible for small systems, since the number of gates required scales exponentially with n and t for large n. Random circuit constructions have two major disadvantages, namely that they require a source of classical randomness, which can be expensive if it needs to be reliable, and that they require the reconfiguring of physical quantum gates, which is bound to introduce noise.

A measurement-based approach[15,16], inspired by measurement-based quantum computing[17,18], avoids both these problems at the cost of additional qubits. Measurement-based quantum computing is an alternative method to perform quantum computing, where the computation is carried out by performing single-qubit measurements on an entangled resource state instead of by applying unitary operations (or gates) as with the circuit model. Reducing the entire computation to single-qubit measurements has the benefit of avoiding the swapping of qubits around a large circuit, which would introduce additional noise. Measurement-based quantum computing is advantageous in physical systems, such as photonic or superconducting systems, or cold atoms, where the qubits to be entangled are spatially close to each other so that the entangled resource state can be generated efficiently.

Measurement-based t-designs are realised by performing a deterministic sequence of single-qubit measurements on a highly entangled graph state. Turner and Markham present a measurement-based protocol for realising an exact single-qubit 3-design, which requires a 6-qubit graph state, and discuss measurement-based protocols for realising higher order approximate single-qubit t-designs, which require larger graph states[15]. Efficient approximate n-qubit measurement-based t-designs, where the number of qubits in the entangled resource state scale polynomially with n and t, have also been found[16]. It is still unknown whether exact single-qubit measurement-based t-designs exist for or whether exact multi-qubit measurement-based t-designs exist at all.

In previous experiments, multi-qubit pseudorandom ensembles, in which the expected distribution of matrix elements of unitary operators sampled from the uniform Haar ensemble is reproduced, have been realised using a nuclear magnetic resonance quantum processor[19] and single-qubit 1-designs and 2-designs have been realised using photons[20]. In this paper, we implement the exact single-qubit measurement-based 3-design of Ref.[15] and our own approximate single-qubit measurement-based 2-design on IBM superconducting quantum computers, accessible through their website[21]. These were implemented by performing single-qubit measurements on 6-qubit and 5-qubit graph states respectively. Since measurement errors are responsible for a significant amount of noise on IBM quantum processors, and since this noise is predominantly classical, we performed quantum readout error mitigation to improve results[22]. Both the exact 3-design implementation and the approximate 2-design implementation passed our test for a 1-design, but not for a 2-design or a 3-design. Further investigations, presented in the supplementary information, suggest that depolarising noise is likely what prevented these implementations from passing the test for a 2-design and a 3-design.

This paper is structured as follows. In the “Background” section, we discuss measurement-based processing using graph states and how it can be used to generate t-designs. We also give an overview of the channel tomography technique used to analyse results and the quantum readout error mitigation technique used to improve results. In the “Experiments” section, we describe the implementations of the exact 3-design and approximate 2-design and present the results obtained. Some concluding comments are given in the “Conclusion” section. Supplementary information is included, in which further discussion of the implementations and analysis of the results is presented.

Background

Measurement-based t-designs

Quantum graph states are a fundamental resource for measurement-based quantum computing[17,18], and a wide range of other protocols, including quantum secret sharing[23,24], quantum sensing[25,26] and quantum games[27,28]. A n-qubit graph state is defined in relation to a connected graph with n vertices. Such a graph state is made by preparing each qubit in the state and then applying controlled phase gates , between a pair of qubits whenever their corresponding vertices are connected by an edge in the corresponding graph[29]. Linear cluster states are graph states corresponding to a graph in which the degree of each vertex is less than or equal to 2 (excluding rings).

Unitary operations can be implemented by performing single-qubit measurements on linear cluster states[29], as illustrated in Fig. 1. The first qubit is prepared in the input state, , to which the implemented unitary operation is to be applied. The remaining qubits are prepared in the state (Step 1), and qubits are then entangled via controlled phase gates applied between adjacent qubits (Step 2). Each of the qubits 1 to are then measured in the basis with , which we will refer to as a measurement in the -direction, and which reduces to a measurement in the Pauli X-basis, , when . This results in the qubit being prepared in the output state, (Step 3).

Figure 1

Summary of measurement-based processing with a n-qubit linear cluster state. Step 1 shows the initialisation of the qubits. Step 2 shows the entangled cluster state (after application of controlled phase gates between adjacent qubits) as well as the measurements performed on each qubit. Step 3 shows the state resulting from these measurements.

Each measurement in the -direction is logically equivalent to applying the random unitary,to where is the random measurement outcome, H is a Hadamard, Z is the Pauli Z operation and is a z-rotation by the angle . Hence, a n-qubit linear cluster implements the random unitarywhere qubit i is measured in the -direction with and is the result of this measurement. Here and denote ordered lists of angles and measurement outcomes respectively. To present lists of measurement outcomes, we use little endian encoding, that is, they are presented as bit strings in which the leftmost bit is the outcome of the measurement on qubit and the rightmost bit is the outcome of the measurement on qubit 1. This is in correspondence with how measurement outcomes are presented on IBM processors.

Now, given , consider the ensemble of unitaries for all . Note that by the linearity of the cluster, for all , so that the distribution is uniform. An ensemble of unitaries is an -approximate t-design if there exists an such that for all , with , we havewhere the matrix inequality holds if is positive semidefinite andis the expectation of the uniform Haar ensemble. For exact t-designs . Turner and Markham[15] show that for the 6-qubit cluster state and measurement angles , , , and , the ensemble , which consists of the 32 unitaries corresponding to the 32 possible measurement outcomes , is an exact 3-design.

Channel tomography

Channel tomography can be used to determine the extent to which the predicted unitary operations are realised by cluster state implementations in an experiment. We consider a method proposed for single-qubit channels by Nielsen and Chuang[30,31]. Given any input state , we write the output state aswhere , , , and is a 4 by 4 matrix. Since the operators are fixed, the channel is fully characterised by , and so channel tomography amounts to determining . The entries of depend on the action of the channel on the probe input states, , , and , which is determined by performing state tomography on the output state for these input states. In particular,where the submatrices of the middle matrix are defined bywhere , , and denote the output states determined for the respective probe input states. Once constructed, we can use to quantify the reliability with which an expected channel is realised in an experiment, by calculating the channel fidelity,where is the matrix which corresponds to the expected operation of the channel, and is the matrix of the actual channel obtained from channel tomography. The channel fidelity ranges from 0 to 1, where 0 indicates that the channel deviates maximally from its expected operation and 1 indicates a perfect channel.

Quantum readout error mitigation

As a result of measurement errors, actual quantum states and channels are often more similar to expected states and channels than tomography results would suggest. Since measurement errors on IBM quantum processors are mostly classical[22], quantum readout error mitigation can be used to obtain tomography results which more accurately reflect the prepared states and channels, as has been successfully done in a number of recent studies which also involved measurements on highly entangled states on IBM quantum processors[32-34]. To mitigate readout errors in a n-qubit experiment (the main experiment), we first use quantum detector tomography[35] to construct a by calibration matrix . The entries of are the conditional probabilities of measuring each of the possible combinations of computational basis states, given that a specific combination of computational basis states was prepared, for all possible combinations of computational basis states. In particular, each column of contains the conditional probabilities associated with one of the prepared combinations of computational basis states. These conditional probabilities are determined in a series of separate experiments, in which each of the possible combinations of computational basis states is prepared on the n qubits to be used in the main experiment and sufficient computational basis measurements are done to infer the associated conditional probabilities. Once constructed, can be used to correct classical measurement errors in the main experiment by multiplying by , the column vector containing the relative frequencies obtained in the main experiment. As a result of other noise, such as gate errors, the resulting vector, , may be non-physical (relative frequencies may be negative or may not sum to one). We therefore use qiskit’s built-in method[36], which solves a constrained optimisation problem (least squares method), to find the closest physical relative frequency vector to .

Experiments

Implementation

The exact measurement-based 3-design proposed by Turner and Markham[15] and described in the “Measurement-based t-designs” section was implemented on 6 physical qubits of the ibmq_toronto quantum processor. Supplementary information I provides more details on the ibmq_toronto quantum processor and how the logical qubits 1 to 6 were mapped onto the physical qubits of this processor. The 4 channel tomography probe states were considered as input states. For each input state, we prepared the 6-qubit linear cluster state and performed the appropriate single-qubit measurements. Quantum state tomography was then done on the sixth qubit to construct the output state obtained for each of the 32 different measurement outcomes. A general quantum circuit for the implementation is shown in Fig. 2.

Figure 2

General quantum circuit for implementation of the exact measurement-based 3-design of Ref.[15] on the ibmq_toronto quantum processor. Here ‘in’ represents the set of gates applied to construct the input state and ‘out’ represents the set of gates applied and measurements done to perform tomography on the sixth qubit. The angles for the z-rotation gates are and .

Qubits are initialised in the state by default on IBM processors, and so the state was prepared by applying the Pauli X operation, the state was prepared by applying a Hadamard and the state was prepared by applying a Hadamard, followed by a S-gate. Since IBM processors do not support controlled phase gates at the hardware level, we converted the Hadamards and controlled phase gates, needed to prepare the 6-qubit linear cluster state, into Hadamards (H) and controlled not (CX) gates usingand then eliminated redundant Hadamards using the fact that . Doing so ensured that redundant Hadamards, which would have increased noise in the results due to gate errors, were removed from the circuit. Preparing the 6-qubit linear cluster state with controlled phase gates would have resulted in redundant Hadamards being introduced by the transpiler. Since IBM processors can only perform measurements in the computational basis, , measurements in the -direction were realised by applying , followed by a Hadamard, and measuring in the computational basis. Quantum state tomography was done using qiskit’s built-in method[37], which uses maximum-likelihood estimation to ensure that the density matrices constructed from the data are physical (i.e. that they have a trace of 1 and are Hermitian). The state tomography results were used to do channel tomography for each of the 32 different measurement outcomes to determine the extent to which the 32 corresponding unitary operations performed on the input states in the implementation matched the expected unitary operations. The results are presented in the “Channel tomography results” section.

Each of the 12 circuits needed for channel tomography (3 circuits for state tomography to construct the output state for each of the 4 input states) was run 5 times with 8000 shots on the ibmq_toronto quantum processor. The counts obtained in the 5 different runs of the same circuit were then combined to obtain an effective run with 40000 shots for each of the 12 circuits. This was done to decrease statistical noise in the tomography results. The procedure was repeated 10 times to obtain 10 sets of channel tomography results ( matrices) for each of the 32 different unitary operations. Associated results, such as channel fidelities, quoted in the sections which follow, are an average of these 10 repetitions and the errors quoted are the standard deviations.

To obtain the conditional probabilities needed to construct the calibration matrix, required to mitigate readout errors in the tomography results, we prepared each of the 64 possible combinations of computational basis states on the same 6 qubits of the ibmq_toronto quantum processor as was used for the 3-design implementation and measured these qubits in the computational basis. Each of the 64 circuits was run with 8000 shots and no combination of counts was done. Readout errors in the raw tomography data (i.e. the counts obtained by running the various circuits) were then mitigated as described in the “Quantum readout error mitigation” section. Results obtained using both the raw and the processed (error mitigated) data are presented in the sections which follow.

Channel tomography results

Channel tomography results obtained for the two random unitaries, generated with the exact 3-design on the ibmq_toronto quantum processor, which showed the least and most agreement with theoretical predictions, are shown in Figs. 3 and 4 respectively. Channel fidelities for each of the 32 different random unitaries generated with the exact 3-design implementation are given in Table 1 and the distribution of these channel fidelities is displayed in Fig. 5. The average channel fidelity is (0.8220 ± 0.0325) without quantum readout error mitigation and (0.8754 ± 0.0361) with quantum readout error mitigation. Quantum readout error mitigation improved all the channel fidelities, which confirms that classical measurement errors were responsible for a significant amount of noise in the exact measurement-based 3-design implementation, and would have resulted in channel fidelities which greatly underestimate the reliability with which the expected unitary operations are realised in the implementation, if left uncorrected.

Figure 3

Example of channel tomography results for the random unitary that agreed least with the ideal case generated for measurement outcome with the exact 3-design on the ibmq_toronto quantum processor. The diagram at the top shows the entangled 6-qubit cluster state with the measurements performed on each qubit. The matrix obtained without quantum readout error mitigation is shown on the left, the matrix obtained with quantum readout error mitigation is shown in the middle and the ideal matrix is shown on the right. The real part of each matrix is shown above and the imaginary part of each matrix is shown below.

Figure 4

Example of channel tomography results for the random unitary that agreed most with the ideal case generated for measurement outcome with the exact 3-design on the ibmq_toronto quantum processor. The diagram at the top shows the entangled 6-qubit cluster state with the measurements performed on each qubit. The matrix obtained without quantum readout error mitigation is shown on the left, the matrix obtained with quantum readout error mitigation is shown in the middle and the ideal matrix is shown on the right. The real part of each matrix is shown above and the imaginary part of each matrix is shown below.

Table 1

Channel fidelities for the 32 random unitaries, corresponding to the 32 different measurement outcomes, generated with the exact 3-design on the ibmq_toronto quantum processor.

Outcome	Fidelity (Raw)	Fidelity (Processed)
00000	0.7246 ± 0.0064	0.7670 ± 0.0073
00001	0.8090 ± 0.0098	0.8688 ± 0.0106
00010	0.7820 ± 0.0051	0.8397 ± 0.0057
00011	0.8013 ± 0.0106	0.8596 ± 0.0119
00100	0.8061 ± 0.0077	0.8657 ± 0.0084
00101	0.8506 ± 0.0084	0.9192 ± 0.0096
00110	0.8498 ± 0.0060	0.9157 ± 0.0073
00111	0.8358 ± 0.0086	0.8949 ± 0.0095
01000	0.7819 ± 0.0106	0.8295 ± 0.0115
01001	0.8356 ± 0.0082	0.8919 ± 0.0090
01010	0.7865 ± 0.0035	0.8295 ± 0.0041
01011	0.8194 ± 0.0066	0.8715 ± 0.0074
01100	0.8215 ± 0.0061	0.8755 ± 0.0071
01101	0.8426 ± 0.0068	0.8920 ± 0.0075
01110	0.8272 ± 0.0056	0.8708 ± 0.0066
01111	0.8538 ± 0.0059	0.9042 ± 0.0065
10000	0.7503 ± 0.0088	0.7953 ± 0.0101
10001	0.8423 ± 0.0084	0.9056 ± 0.0096
10010	0.8135 ± 0.0072	0.8656 ± 0.0080
10011	0.8203 ± 0.0069	0.8830 ± 0.0081
10100	0.7992 ± 0.0096	0.8569 ± 0.0103
10101	0.8597 ± 0.0066	0.9202 ± 0.0069
10110	0.8645 ± 0.0054	0.9240 ± 0.0060
10111	0.8460 ± 0.0067	0.9035 ± 0.0079
11000	0.8104 ± 0.0078	0.8593 ± 0.0088
11001	0.8774 ± 0.0053	0.9353 ± 0.0060
11010	0.8238 ± 0.0084	0.8689 ± 0.0088
11011	0.8419 ± 0.0066	0.8876 ± 0.0076
11100	0.8013 ± 0.0070	0.8447 ± 0.0077
11101	0.8287 ± 0.0097	0.8765 ± 0.0102
11110	0.8513 ± 0.0047	0.8936 ± 0.0052
11111	0.8467 ± 0.0071	0.8959 ± 0.0081

‘Raw’ shows the channel fidelities without quantum readout error mitigation. ‘Processed’ shows the channel fidelities with quantum readout error mitigation.

Figure 5

Distribution of channel fidelities for the 32 random unitaries generated with the exact 3-design on the ibmq_toronto quantum processor. (a) Raw shows the distribution without quantum readout error mitigation. (b) Processed shows the distribution with quantum readout error mitigation.

Relative frequencies

Due to errors that occur when gates are applied and measurements are made, the relative frequencies with which the 32 random unitaries are generated, with the exact 3-design on the ibmq_toronto quantum processor, do not exactly match the expected uniform probabilities of . To determine the relative frequency with which each unitary is generated, a separate investigation was conducted in which the 6-qubit linear cluster state was prepared on the same 6 physical qubits of the ibmq_toronto quantum processor as was used for the 3-design implementation (see supplementary information I) and the first 5 qubits were measured in the same way as in the 3-design implementation. The relative frequency of each set of measurement outcomes is the relative frequency with which the random unitary corresponding to that set of measurement outcomes is generated. The required circuit was run 5 times with 8000 shots each and counts were once again combined to obtain an effective run with 40000 shots. This was repeated 10 times, so that relative frequencies quoted are an average of 10 repetitions and the errors quoted are the standard deviations. The relative frequencies with which each of the 32 different random unitaries are generated with the exact 3-design on the ibmq_toronto quantum processor are presented in Table 2 and the distribution of these relative frequencies is displayed in Fig. 6. The average relative frequency is (0.03125 ± 0.00355) without quantum readout error mitigation and (0.03125 ± 0.00375) with quantum readout error mitigation. We note that even though the relative frequencies with which the different unitaries are generated deviate from the expected uniform probabilities, the average relative frequency is equal to the expected probability.

Table 2

Relative frequencies with which the 32 random unitaries, corresponding to the 32 different measurement outcomes, are generated with the exact 3-design on the ibmq_toronto quantum processor.

Outcome	Frequency (Raw)	Frequency (Processed)
00000	0.03836 ± 0.00095	0.03664 ± 0.00105
00001	0.03130 ± 0.00057	0.02987 ± 0.00059
00010	0.03372 ± 0.00075	0.03196 ± 0.00083
00011	0.02737 ± 0.00064	0.02632 ± 0.00074
00100	0.02861 ± 0.00097	0.02702 ± 0.00108
00101	0.03335 ± 0.00095	0.03183 ± 0.00108
00110	0.03447 ± 0.00091	0.03367 ± 0.00104
00111	0.03305 ± 0.00082	0.03253 ± 0.00091
01000	0.03535 ± 0.00094	0.03567 ± 0.00107
01001	0.02721 ± 0.00076	0.02699 ± 0.00086
01010	0.03530 ± 0.00085	0.03636 ± 0.00094
01011	0.02716 ± 0.00040	0.02750 ± 0.00048
01100	0.03079 ± 0.00081	0.03089 ± 0.00098
01101	0.03349 ± 0.00069	0.03428 ± 0.00080
01110	0.03477 ± 0.00111	0.03628 ± 0.00131
01111	0.02986 ± 0.00087	0.03124 ± 0.00096
10000	0.03788 ± 0.00110	0.03733 ± 0.00123
10001	0.02789 ± 0.00068	0.02666 ± 0.00074
10010	0.03399 ± 0.00069	0.03379 ± 0.00078
10011	0.02408 ± 0.00051	0.02289 ± 0.00057
10100	0.02548 ± 0.00065	0.02432 ± 0.00075
10101	0.03348 ± 0.00089	0.03325 ± 0.00103
10110	0.03032 ± 0.00066	0.03009 ± 0.00075
10111	0.03238 ± 0.00073	0.03287 ± 0.00081
11000	0.03188 ± 0.00075	0.03221 ± 0.00086
11001	0.02757 ± 0.00050	0.02828 ± 0.00057
11010	0.03254 ± 0.00131	0.03376 ± 0.00148
11011	0.02753 ± 0.00081	0.02886 ± 0.00095
11100	0.03008 ± 0.00094	0.03121 ± 0.00112
11101	0.03017 ± 0.00096	0.03116 ± 0.00110
11110	0.03430 ± 0.00104	0.03673 ± 0.00125
11111	0.02631 ± 0.00111	0.02759 ± 0.00127

‘Raw’ shows the relative frequencies without quantum readout error mitigation. ‘Processed’ shows the relative frequencies with quantum readout error mitigation.

Figure 6

Distribution of relative frequencies with which the 32 random unitaries are generated with the exact 3-design on the ibmq_toronto quantum processor. (a) Raw shows the distribution without quantum readout error mitigation. (b) Processed shows the distribution with quantum readout error mitigation.

Testing for a t-design

The definition of an approximate t-design as given by inequality (3) in the “Measurement-based t-designs” section leads naturally to a simple method for testing whether the ensemble of 32 unitaries generated with the 6-qubit cluster state on the ibmq_toronto quantum processor is at least an approximate t-design. Although this definition applies to any density matrix acting on the tensor product space , we restrict ourselves to density matrices which are t copies of an arbitrary single-qubit density matrix for the purposes of testing. This is sufficient for quantifying the extent to which the unitaries are able to randomise single-qubit states, which is our primary interest here, and can at least provide a lower bound on the for which the ensemble of unitaries is an -approximate t-design with more general states included. The restriction to copies of single-qubit density matrices has two major advantages, namely that the test is computationally feasible for all t, since the number of parameters that need to be varied when creating samples of density matrices would otherwise grow exponentially with t, and that the results can be interpreted geometrically, since single-qubit states can be represented by points in the Bloch sphere. For the purposes of testing, we therefore consider the adapted inequalitywhere are the experimentally determined relative frequencies andwhere are the matrices determined by doing channel tomography for the different unitaries. The test amounts to generating a sample of single-qubit density matrices and finding, for each density matrix in the sample, the smallest possible such that inequality (9) is satisfied. The largest found is the one which ensures that inequality (9) is satisfied for all density matrices in the sample and is therefore the test result.

We set the passing criterion for the test to , by which we simply mean that, for the purposes of this paper, we consider the quality of an approximate t-design acceptable if . In practice, some applications of approximate t-designs may require a smaller value of . We also note that, given an ensemble of unitaries which is an exact t-design or an approximate t-design with , it is generally not possible to say whether this ensemble of unitaries is also an approximate -design with , as this depends on the ensemble. Therefore an ensemble of unitaries which passes our test for an approximate t-design, for a given t, may or may not pass our test for an approximate -design.

To generate a sample of single-qubit density matrices, we first generate a representative sample of points in the Bloch sphere using spherical coordinates. We generate 10 evenly spaced values of r in the range [0, 1], 10 evenly spaced values of in the range and 10 evenly spaced values of in the range . Using the standard conversions from spherical to cartesian coordinates, we compute , and for all combinations of the sampled values of r, and , thereby obtaining 1000 points in the Bloch sphere. Usingwe obtain a sample of 1000 density matrices.

Using our sample of 1000 density matrices, we applied the test for the 1-design, the 2-design and the 3-design to the ensemble of unitaries generated using the ibmq_toronto quantum processor. The expected unitary operations of the exact 3-design described in the “Measurement-based t-designs” section were used to compute for . The test for the 1-design passed. The tests for the 2-design and the 3-design did not pass, as diverged for states close to the surface of the Bloch sphere. Nevertheless, inequality (9) could be satisfied for states close to the centre of the Bloch sphere. This was investigated further by re-applying the tests for the 2-design and the 3-design, this time truncating the values of r considered when generating density matrices so that did not exceed 0.5. The test results are summarised in Table 3. Applying quantum readout error mitigation improved the test results. The changes in the values of resulting from replacing the experimentally determined relative frequencies with uniform probabilities, are mostly within the error margins. This suggests that non-uniformity did not significantly impair the quality of the ensemble.

Table 3

Summary of test results for the ensemble of unitaries generated using the ibmq_toronto quantum processor.

Test	Raw			Processed
	Radius	ϵ	ϵ (uniform)	Radius	ϵ	ϵ (uniform)
1-design	1.00	0.0777 ± 0.0066	0.0760 ± 0.0072	1.00	0.0683 ± 0.0054	0.0677 ± 0.0072
2-design	0.68	0.4543 ± 0.0074	0.4559 ± 0.0063	0.75	0.4538 ± 0.0188	0.4464 ± 0.0179
3-design	0.66	0.4590 ± 0.0061	0.4592 ± 0.0070	0.69	0.4814 ± 0.0062	0.4696 ± 0.0058

‘Raw’ shows the results without quantum readout error mitigation. ‘Processed’ shows the results with quantum readout error mitigation. ‘Radius’ is the truncation radius considered for a test. The column with ‘uniform’ shows the values of obtained when replacing the experimentally determined relative frequencies with uniform probabilities.

The divergence in observed for states close to the surface of the Bloch sphere is likely a result of pure states becoming inaccessible due to depolarising noise and was investigated further by applying the test for the 1-design, the 2-design and the 3-design to an exact 3-design combined with a depolarising channel. The full study is presented in supplementary information II and shows that depolarising noise is a very good noise model for the data. Our measurement-based implementation of the identity operation (see supplementary information III) shows that depolarising noise is the predominant type of noise in measurement-based processes on IBM processors, providing further confirmation that depolarising noise is indeed what prevented the tests for the 2-design and the 3-design from passing. Urbanek et al. recently proposed a method for mitigating depolarising noise in quantum computations where the final outcome is an expectation value[38]. Since the final outcome of our implementation is a quantum process or channel, and not an expectation value, this method is unfortunately not applicable here. However, their method may have potential for improving results in applications of measurement-based t-designs where the final outcome is an expectation value.

To determine the fraction of the Bloch sphere for which a test passes, we consider 8000 evenly spaced points in a cube which encloses the Bloch sphere. Points in the Bloch sphere then correspond to valid states. For each valid state, we determine whether inequality (9) can be satisfied with . The fraction of the Bloch sphere for which a test passes is given by the number of states for which the inequality can be satisfied divided by the number of states considered. The fraction of states for which the ensemble of unitaries generated using the ibmq_toronto quantum processor passed the test for the 1-design, the 2-design and the 3-design are given in Table 4. The fraction of states for which the test for the 2-design and the 3-design pass is substantially improved by quantum readout error mitigation. This confirms that classical measurement noise is responsible for many states failing to satisfy inequality (9) and, if left uncorrected, would result in test results which greatly underestimate the extent to which the various designs are realised by our implementation on the ibmq_toronto quantum processor.

Table 4

Fraction of states for which the ensemble of unitaries generated using the ibmq_toronto quantum processor passed the different tests.

Test	Raw		Processed
	Frac	Frac (uniform)	Frac	Frac (uniform)
1-design	1.0000	1.0000	1.0000	1.0000
2-design	0.3834 ± 0.0027	0.3858 ± 0.0034	0.5648 ± 0.0079	0.5768 ± 0.0081
3-design	0.3473 ± 0.0048	0.3534 ± 0.0054	0.5315 ± 0.0061	0.5454 ± 0.0073

‘Raw’ shows the fractions without quantum readout error mitigation. ‘Processed’ shows the fractions with quantum readout error mitigation. The column with ‘uniform’ shows the fractions obtained when replacing the experimentally determined relative frequencies with uniform probabilities.

Approximate 2-design

Turner and Markham[15] show that there is no set of measurement angles such that the ensemble of unitaries generated by performing single-qubit measurements on the 5-qubit linear cluster state is an exact 2-design. However, applying our test for an approximate 2-design to the expected ensemble of unitaries generated for the 5-qubit cluster state and the measurement angles , , and yields . Hence this ensemble is an approximate 2-design, with our passing criterion, although it must be noted that the ensemble does not resemble an exact 2-design closely and that the passing criterion is satisfied only for the subset of density matrices in which are tensor products of pairs of single-qubit states. We implemented this approximate measurement-based 2-design on 5 physical qubits of the ibmq_sydney quantum processor. Supplementary information IV provides more detail on the ibmq_sydney quantum processor, the qubits that were used and why the ibmq_sydney quantum processor was used for this experiment instead of the ibmq_toronto quantum processor. Generation of channel tomography results for the 16 different unitary operations corresponding to the 16 different measurement outcomes, determining of relative frequencies, combining of counts to reduce statistical noise and construction of calibration matrices for quantum readout error mitigation were all done in the same way as for the exact 3-design implementation on the ibmq_toronto quantum processor.

Channel fidelities for each of the 16 different random unitaries are given in Table 5. The average channel fidelity is (0.8596 ± 0.0356) without quantum readout error mitigation and (0.9312 ± 0.0323) with quantum readout error mitigation. The average channel fidelity is larger than the average channel fidelity for the exact 3-design implementation, reflecting reduced noise in the implementation with the smaller cluster state with fewer qubits. The relative frequencies with which each of the 16 different random unitaries are generated are given in Table 6. The average relative frequency is (0.06250 ± 0.01127) without quantum readout error mitigation and (0.06250 ± 0.00871) with quantum readout error mitigation. The average relative frequency is once again equal to the expected uniform probability of .

Table 5

Channel fidelities for the 16 random unitaries, corresponding to the 16 different measurement outcomes, generated with the approximate 2-design on the ibmq_sydney quantum processor.

Outcome	Fidelity (Raw)	Fidelity (Processed)
0000	0.7931 ± 0.0033	0.8947 ± 0.0038
0001	0.8871 ± 0.0042	0.9851 ± 0.0047
0010	0.8382 ± 0.0051	0.9220 ± 0.0061
0011	0.8506 ± 0.0040	0.9242 ± 0.0047
0100	0.8231 ± 0.0062	0.8900 ± 0.0069
0101	0.8912 ± 0.0053	0.9649 ± 0.0053
0110	0.8399 ± 0.0051	0.8978 ± 0.0058
0111	0.8885 ± 0.0041	0.9378 ± 0.0047
1000	0.7991 ± 0.0039	0.8978 ± 0.0044
1001	0.9039 ± 0.0053	0.9944 ± 0.0063
1010	0.8365 ± 0.0058	0.9061 ± 0.0062
1011	0.8885 ± 0.0059	0.9527 ± 0.0061
1100	0.8487 ± 0.0052	0.9183 ± 0.0054
1101	0.9052 ± 0.0055	0.9639 ± 0.0055
1110	0.8571 ± 0.0030	0.9053 ± 0.0031
1111	0.9027 ± 0.0060	0.9448 ± 0.0066

‘Raw’ shows the channel fidelities without quantum readout error mitigation. ‘Processed’ shows the channel fidelities with quantum readout error mitigation.

Table 6

Relative frequencies with which the 16 random unitaries, corresponding to the 16 different measurement outcomes, are generated with the approximate 2-design on the ibmq_sydney quantum processor.

Outcome	Frequency (Raw)	Frequency (Processed)
0000	0.07835 ± 0.00104	0.06486 ± 0.00113
0001	0.06705 ± 0.00151	0.06268 ± 0.00169
0010	0.07319 ± 0.00100	0.06585 ± 0.00122
0011	0.05817 ± 0.00074	0.05930 ± 0.00091
0100	0.07856 ± 0.00119	0.07513 ± 0.00138
0101	0.05442 ± 0.00073	0.05646 ± 0.00096
0110	0.07869 ± 0.00115	0.08351 ± 0.00144
0111	0.04837 ± 0.00095	0.05567 ± 0.00121
1000	0.06820 ± 0.00120	0.05981 ± 0.00137
1001	0.05429 ± 0.00100	0.05296 ± 0.00120
1010	0.06837 ± 0.00120	0.06680 ± 0.00135
1011	0.04801 ± 0.00088	0.05098 ± 0.00107
1100	0.06347 ± 0.00120	0.06286 ± 0.00150
1101	0.04988 ± 0.00149	0.05518 ± 0.00191
1110	0.06642 ± 0.00137	0.07384 ± 0.00168
1111	0.04458 ± 0.00125	0.05411 ± 0.00164

‘Raw’ shows the relative frequencies without quantum readout error mitigation. ‘Processed’ shows the relative frequencies with quantum readout error mitigation.

We applied our test for the 1-design and the 2-design to the ensemble of unitaries generated using the ibmq_sydney quantum processor. The test for the 1-design passed, but the test for the 2-design did not. Test results are summarised in Table 7 and the fraction of states for which each test passed is conveyed in Table 8. The values of obtained for the ensemble of unitaries generated using the ibmq_sydney quantum processor, for a given truncation radius, are not much larger than the expected values for the approximate 2-design. This suggests that inherent deviations from an exact 2-design, present in the approximate 2-design considered, had a more significant effect on the quality of the ensemble of unitaires than noise on the ibmq_sydney quantum processor.

Table 7

Summary of test results for the ensemble of unitaries generated using the ibmq_sydney quantum processor.

Test	Raw				Processed
	Radius	ϵ	ϵ (uniform)	ϵ (ideal)	Radius	ϵ	ϵ (uniform)	ϵ (ideal)
1-design	1.00	0.1505 ± 0.0056	0.1468 ± 0.0073	0.0000	1.00	0.1505 ± 0.0056	0.1397 ± 0.0065	0.0000
2-design	0.69	0.4488 ± 0.0035	0.4690 ± 0.0052	0.2739	0.81	0.4623 ± 0.0103	0.4865 ± 0.0073	0.3589

‘Raw’ shows the results without quantum readout error mitigation. ‘Processed’ shows the results with quantum readout error mitigation. ‘Radius’ is the truncation radius considered for a test. The column with ‘uniform’ shows the values of obtained when replacing the experimentally determined relative frequencies with uniform probabilities. The column with ‘ideal’ shows the expected values of for the approximate 2-design for the truncation radii considered.

Table 8

Fraction of states for which the ensemble of unitaries generated using the ibmq_sydney quantum processor passed the different tests.

Test	Raw		Processed
	Frac	Frac (uniform)	Frac	Frac (uniform)
1-design	1.0000	1.0000	1.0000	1.0000
2-design	0.3984 ± 0.0017	0.4104 ± 0.0020	0.6773 ± 0.0095	0.6925 ± 0.0050

‘Raw’ shows the fractions without quantum readout error mitigation. ‘Processed’ shows the fractions with quantum readout error mitigation. The column with ‘uniform’ shows the fractions obtained when replacing the experimentally determined relative frequencies with uniform probabilities.

The fraction of states for which the test for the 2-design passed with quantum readout error mitigation is almost double that without quantum readout error mitigation. This confirms that the noise in this implementation was also predominantly classical measurement errors. The effect of readout errors was more pronounced in this implementation, likely because gate errors of the qubits used are much smaller (see supplementary information IV). We note that the fraction of states for which the ensemble of unitaries generated with the 5-qubit cluster state on the ibmq_sydney quantum processor passed the test for the 2-design, especially with quantum readout error mitigation, is larger than that of the ensemble of unitaries generated with the 6-qubit cluster state on the ibmq_toronto quantum processor. Hence, even though the approximate 2-design considered does not closely resemble an exact 2-design, the ensemble of unitaries generated with this approximate 2-design implementation more closely resembles a 2-design than the ensemble of unitaries generated with the exact 3-design implementation. This is as a result of significantly reduced noise in the implementation with the smaller 5-qubit cluster state, compared to the implementation with the larger 6-qubit cluster state.

Conclusion

The exact measurement-based 3-design of Ref.[15] was implemented by performing single-qubit measurements on a 6-qubit linear cluster state, prepared on the ibmq_toronto quantum processor. To infer the ensemble of unitaries realised in the implementation, we performed channel tomography for all possible measurement outcomes. This ensemble of unitaries passed our test for a 1-design, but not for a 2-design or a 3-design. Further studies, presented in supplementary information II and III, strongly suggest that depolarising noise prevented the tests for the 2-design and the 3-design from passing. Therefore, for measurement-based t-designs to be effectively realised for on superconducting systems, such as IBM quantum processors, a significant amount of work will need to be done to reduce or mitigate depolarising noise in these devices.

The noteworthy improvement in results obtained by applying quantum readout error mitigation confirms that classical measurement errors are indeed responsible for a substantial amount of noise on IBM quantum processors in this instance. It also shows the importance of mitigating these errors, as not doing so would lead to results that give an inaccurate account of the actual implementations realised on these processors. The ensemble of unitaries realised by our approximate measurement-based 2-design implementation, in which single-qubit measurements were performed on a 5-qubit linear cluster state prepared on the ibmq_sydney quantum processor, showed improved results for the 2-design test as a result of reduced noise for the smaller 5-qubit cluster state. This clearly demonstrates the advantage of keeping entangled resource states used in measurement-based processes small. It also shows that in experimental realisations (where noise is present), the quality of a noisy approximate t-design may be better than the quality of a noisy exact t-design, if the implementation of the approximate t-design is significantly less sensitive to noise than the implementation of the exact t-design.

Supplementary Information.