VeriQBench: A Benchmark for Multiple Types of Quantum Circuits
1,3]Kean Chen
1,3]Wang Fang
<EMAIL_ADDRESS>Guan
Xin Hong
1,3]Mingyu Huang
1,3]Junyi Liu
2]Qisheng Wang
<EMAIL_ADDRESS>Ying
[1]State Key Laboratory of Computer Science, Institute of Software, Chinese Academy of Sciences, China
[2]Department of Computer Science and Technology, Tsinghua University, China
[3]The University of Chinese Academy of Sciences, China
[4]Centre for Quantum Software and Information, University of Technology Sydney, Australia

In this paper, we introduce VeriQBench — an open source benchmark for quantum circuits. It offers high-level quantum circuit abstractions of various circuit types,  including: 1) combinational, 2) dynamic, 3) sequential, and 4) variational quantum circuits, which cover almost all existing types of quantum circuits in the literature.
Meanwhile, VeriQBench is a versatile benchmark which can be used in verifying quantum software for different applications, as is evidenced by the existing works including quantum circuit verification (e.g., equivalence checking <cit.> and model checking <cit.>), simulation (e.g., fault simulation), testing (e.g., test pattern generation <cit.>) and debugging (e.g., runtime assertions <cit.>).
All the circuits are described in OpenQASM and are validated on Qiskit and QCOR simulators. With the hope that it can be used by other researchers,  VeriQBench is released at: <https://github.com/Veri-Q/Benchmark>.

§ INTRODUCTION

Quantum circuits are the basic  components in quantum computing.
With the rapid development in hardware implementation of quantum circuits in  experiments, there also emerge many approaches to characterise and evaluate  quantum computing models by  simulating and comparing quantum circuits, such as quantum noise effects <cit.>, variational circuit training <cit.> and  (approximate) equivalence checking

<cit.>. In particular,
quantifying the practical performance of some carefully chosen quantum circuits is a common way to evaluate the performance of quantum devices, especially in the current NISQ (Noisy Intermediate-Scale Quantum) era, where quantum noise from the surrounding environment is unavoidable.  These quantum circuits are generated from different fields, such as random protocols <cit.>,
quantum algorithms <cit.>,

including variational quantum algorithms <cit.> and classical reversible circuits <cit.>. Subsequently, in the recent years, diverse quantum circuit benchmarks have been  proposed with different evaluation metrics, such as QASMBench <cit.>, quantum LINPACK benchmark <cit.>,  SupermarQ <cit.> and the quantum volume protocol <cit.>.

In this paper, we present a new quantum circuit benchmark, called VeriQBench, for a different purpose. It was initially designed for testing our own QDA (Design Automation for Quantum Computing) tool series $\textit{VeriQ}$. But  we hope it can be  applicable in various fields, given the following features:

* Diversity: It includes the most commonly-used  quantum circuits, namely  combinational quantum circuits, dynamic quantum circuits, sequential quantum circuits, and variational quantum circuits.
These circuits cover all types of quantum circuits existing in the literature. Furthermore, the quantum circuits in our benchmark are diverse in structure (e.g. the layout of 2-qubit circuits) and complexity (e.g. circuit size and depth).

* Scalability: The circuit scales in our benchmark vary widely, ranging from 2 qubits up to $>50$ qubits, which are divided into three classes, i.e. small-scale ($<20$ qubits), medium-scale ($20-50$ qubits) and large-scale ($>50$ qubits).

* Easy-to-use: All the circuits in our benchmark are described using the OpenQASM quantum assembly language and provided as “.qasm” files. Furthermore, most of them can be converted to other representations such as Q#, PyQuil, Cirq, etc. through q-convert tool, which is available online: <http://quantum-circuit.com/qconvert>.

* Evolvement:  For most of the quantum circuits in our benchmark, we provide a series of scripts for users to generate quantum circuits of an arbitrary number of qubits. This ensures that our benchmark can  evolve as the available circuit scales of quantum technologies increase.

Our benchmark can work with different evaluation metrics to verify quantum software — comparing and assessing the effectiveness and efficiency of quantum and classical (simulation) algorithms designed for quantum circuits. The circuits in our benchmark are collected from researches in a variety of fields, including equivalence checking <cit.>, circuit testing <cit.> and circuit optimizing <cit.>. This improves  the diversity and practical feasibility of the benchmark. On this basis, the circuit types and scales are further extended and standardized to form a scalable and evolvable benchmark.
To demonstrate the validity, all quantum circuits in our benchmark are implemented and validated by Qiskit <cit.> — an open source SDK for quantum computation, and QCOR <cit.> — a programming language and a compiler for the heterogeneous quantum-classical model of computation.

This paper is organised as follows: we start from the basic type of quantum circuits, namely combinational quantum circuits in Section <ref>, which includes some fundamental quantum algorithms, reversible circuits, qubit mapping and random quantum circuits. Then dynamic, sequential and variational quantum circuits are presented in Sections <ref>, <ref> and <ref>, respectively. In Section <ref>, we validate all quantum circuits on Qiskit and QCOR. In the last section, we discuss some example applications of the benchmarks. Of course, we hope that this benchmark can be used by other researchers. The benchmark VeriQBench is released at: <https://github.com/Veri-Q/Benchmark>.

§ COMBINATIONAL QUANTUM CIRCUITS

The most basic and commonly used type of quantum circuit is the combinational quantum circuit, with examples  including some of the popular quantum algorithms such as the Bernstein-Vazirani algorithm, quantum Fourier transform and quantum phase estimation. In our benchmark, we include the most commonly used combinational circuits and divide them into four categories: quantum algorithms, reversible circuits, circuits for qubit mapping, and random quantum circuits.

§.§ Quantum Algorithms

§.§.§ Bernstein-Vazirani Algorithm

Bernstein-Vazirani algorithm <cit.> is an algorithm that can be used to find the hidden string $s$ given a boolean function $f(x)$, where $f(x)=\langle s,x \rangle=s_0x_0\oplus s_1x_1\oplus\cdots \oplus s_nx_n$. For the classical algorithm, it normally needs $\mathcal{O}(n)$ times to complete this task using a bit-by-bit inquiring method. But, it only needs $\mathcal{O}(1)$ times using the Bernstein-Vazirani algorithm suppose that you are given an orcle $O_s$, where $O_s\ket{x}\ket{y}=\ket{x}\ket{f(x)\oplus y}$.

First, apply a series of Hadamard gates to state $\ket{0}\cdots\ket{0}\ket{1}$ to change the state to $\frac{1}{\sqrt{2}^n} \sum_{x=0}^{2^n-1}{\ket{x}}\otimes \frac{\ket{0}-\ket{1}}{\sqrt{2}}$. Then, applying the oracle, the state will become $\frac{1}{\sqrt{2}^n} \sum_{x=0}^{2^n-1}{(-1)^{\langle s,x \rangle}\ket{x}}\otimes \frac{\ket{0}-\ket{1}}{\sqrt{2}}$. Finally, apply a series of Hadamard gates, and the final state will change to $\ket{s}\ket{1}$. At the end, measuring the first $n$ qubits gives the value of $s$.

For $s=101$ and $s=111$, the corresponding circuits are shown in Figure <ref>. In these two circuits, an $X$ gate is added at the last qubit to change the initial state from $\ket{0}$ to $\ket{1}$, and the $CNOT$ gates are used for implementing the oracle. For these circuits, setting input state $\ket{0}\cdots \ket{0}$ and measuring at the end will give the hidden string $s$.

@C=.5em @R=0em @!R
H        3        H

H               H

H           1    H

X     H           H

@C=.5em @R=0em @!R
H        3           H

H           2        H

H              1    H

X     H              H

Two examples of the Bernstein-Vazirani algorithm, where (a) $s=101$ and (b) $s=111$.

OpenQASM Code. The following gives the description of the circuit for $s=101$ using OpenQASM 2.0.

Generation Script. The circuit for arbitrary hidden string $s$ can be generated using the following code. For this circuit, the number of qubits is expected to be one more than the length of the hidden string.

[language = Python]files/Combinational_Cir/bv.py

§.§.§ Quantum Fourier Transform

Description. Quantum Fourier transform <cit.> is a commonly used algorithm in quantum computing. It turns an input state $\ket{j}$ to its Fourier transform.

$$QFT\ket{j}=\frac{1}{\sqrt{N}}\sum_{k=0}^{N-1}e^{2\pi ijk/N}\ket{k}.$$

The circuit for 3-qubit quantum Fourier transform is shown in Figure <ref>. It is easy to observe from this circuit that the quantum Fourier transform can be implemented using a series of Hadamard gates and a set of Control-$R_k$ gates, where

R_k=\begin{bmatrix} 1&0\\0&e^{2\pi i/2^k} \end{bmatrix}.

@C=0.7em @R=0.4em
|j_1⟩      H    1     2                  |0⟩+e^0.j_1j_2j_3|1⟩

|j_2⟩         R_2      H    1             |0⟩+e^0.j_2j_3|1⟩

|j_3⟩            R_3      R_2    H        |0⟩+e^0.j_3|1⟩

Quantum circuit for Fourier Transform.

OpenQASM Code. The OpenQASM 2.0 description of this circuit is shown below.

Generation Script. The circuit for arbitrary number of qubits quantum Fourier transform can be generated using the following code. This code extended the circuit shown in Figure <ref> to arbitrary qubits.

[language = Python]files/Combinational_Cir/qft.py

§.§.§ Quantum Phase Estimation

Description. Phase estimation <cit.> is an algorithm that can be used to estimate the phase $\varphi$ in an eigenvalue of a unitary $U$, where $U\ket{\psi}=e^{2\pi i\varphi}\ket{\psi}$ for some $\ket{\psi}$. The corresponding circuit is shown in Figure <ref>.

@C=0.7em @R=0.4em
|0⟩      H       2     H    1

|0⟩      H    1          R_2^†   H

|ϕ⟩     /   U    U^2

Quantum circuit for phase estimation.

The process can be conducted by first constructing an superposition state and then applying a series of controlled-$U^{2^k}$ gates. Then, an inverse quantum Fourier transform can be used to extract the corresponding value of the phase.

OpenQASM Code. The following gives the OpenQASM 2.0 description of this circuit. In this circuit, we suppose that $U$ is a single qubit diagonal matrix

$$U=\begin{bmatrix}1&0\\0&e^{2\pi i \varphi} \end{bmatrix},$$

and here we take $\varphi=1/1024$ as an example.

Generation Script. The python code for generating the circuits is as follows. You can assign the number of qubits of the circuit and also the phase $\varphi$. Then, running this circuit will give the estimation of the phase to a precision restricted by the number of qubits.

[language = Python]files/Combinational_Cir/pe.py

§.§.§ Grover's Algorithm

Description. Grover's algorithm <cit.> is one of the most commonly used algorithms in quantum computing to search the solution of an integer function.

Suppose you are given an oracle $O$ such that $O\ket{x}=(-1)^{f(x)}\ket{x}$, then initialise the state to be the equal superposition state $\ket{\psi}=\frac{1}{N^{1/2}}\sum_{x=0}^{N-1}{\ket{x}}$, and iteratively apply the Grover operator

and finally measure all the qubits, you will get a solution of the function $f(x)$ with a probability close to 1.

Figure <ref> gives an example of the Grover's algorithm. Here, $f(x)=x_1 \cdot x_2$, running this circuit and measuring at the end will obtain $11$, which is the solution of this function.

@C=0.7em @R=0.4em
H    1    H    X       1       X    H

H    1    H    X    H       H    X    H

H                         H

An example of Grover's algorithm. Here, $f(x)$ is a 2-bit function and $f(x)=x_1 \cdot x_2$.

OpenQASM Code. The OpenQASM 2.0 description of this circuit is as follows.

Generation Script. The python code for generating circuits for arbitrary qubits Grover's search is as follows. In this code, you can assign the number of qubits $n$ of the search space, where the solution is $\ket{1}^{\otimes n}$. Then there will be one qubit serving as oracle workspace and $n-2$ qubits as ancilla qubits. Thus, the circuit will totally have $2n-1$ qubits and the $C^n(X)$ will be decomposed to a series of $CCX$ (i.e. Toffoli) gates using the ancilla qubits.

[language = Python]files/Combinational_Cir/grover.py

§.§.§ Quantum Adder

Description. Quantum adder is a quantum circuit to implement add operation on two bit strings. For example, if we compute '2+3=5', then we represent the input string as '010' and '011', and the expected output bit string is '101'. The implementation of the quantum adder circuit is illustrated as follows, and the additional qubits are used to store the carry bit <cit.>.

OpenQASM Code. The OpenQASM description of 3-bit adder circuit is shown as follows.

@C=1.0em @R=0.8em @!R

q_0 :        q_0 :               2     2

q_1 :        q_1 :       1     1

q_2 :        q_2 :       1         1

q_3 :        q_3 :                   2     2

q_4 :        q_4 :       1     1

q_5 :        q_5 :       1             1

q_6 :        q_6 :                       2     2

q_7 :        q_7 :       1     1

q_8 :        q_8 :       1                 1

q_9 :        q_9 :

Circuit of 3-bit adder

Generation Script. The python code for generating an adder circuit is as follows, the function takes the number of qubits as the input and outputs the OpenQASM text of the circuit.

[language = Python]files/Combinational_Cir/adder.py

§.§ Reversible Circuits

Description. A classical \(n\)-bit reversible gate is a bijective mapping \(f\) from the set \(\{0,1\}^n\) of \(n\)-bit data onto itself. Thus the vector of input states can always be reconstructed from the vector of output states. A combinational logic circuit is reversible if it only contains reversible gates and has no fan-out. Classical reversible circuits may be implemented in quantum technology and have important applications in many quantum algorithms such as the arithmetic module of Shor's Algorithm and the oracle of Grover's Algorithm.

We collect the classical reversible circuits in the Reversible Logic Synthesis Benchmarks Page <cit.>. The following are the elementary gates they used:

A generalized Toffoli gate TOF(\(x_1\), \(x_2\), ..., \(x_n\); \(x_{n+1}\)) is a gate which maps a Boolean pattern (\(x_1\), \(x_2\), ..., \(x_n\), \(x_{n+1}\)) to (\(x_1\), \(x_2\), ..., \(x_n\), \(x_{n+1}+x_1x_2\ldots x_n\)), where "+" is a modula-2 addition.

* NOT gate is a TOF(\(\emptyset;a\)) gate.

* CNOT gate is a TOF(\(a;b\)) gate.

* Original Toffoli gate is a TOF(\(a,b;c\)).

A generalized Fredkin gate FRE(\(x_1\), \(x_2\), ..., \(x_n\); \(x_{n+1}\), \(x_{n+2}\)) is a gate which maps Boolean pattern (\(x_1\), \(x_2\), ..., \(x_n\), \(x_{n+1}\), \(x_{n+2}\)) to (\(x_1\), \(x_2\), ..., \(x_n\), \(x_{n+2}\), \(x_{n+1}\)) if and only if Boolean product \(x_1x_2\ldots x_n = 1\), otherwise the pattern is unchanged.

* SWAP gate is a FRE(\(\emptyset;a,b\)) gate.

* Original Fredkin gate is a FRE(\(a;b,c\)) gate.

OpenQASM Code. We translate their circuit description into the OpenQASM 2.0 format. The following gives an example of the reversible 5-bit adder circuit.

§.§ Qubit Mapping

Description. On the current superconducting quantum processors, 2-qubit gates are usually  unavailable for arbitrary pairs of qubits but only for a small part of them. In order to make all the 2-qubit gates in a circuit available on a specific quantum chip, we have to map the qubits in the circuit to those on the quantum chip and insert some SWAP gates. Meanwhile, we want to make sure that the modified circuit is optimal on depth or the number of inserted SWAP gates. However, since the above problem, known as the qubit mapping problem, is NP-complete, it is difficult to theoretically evaluate the performance of different algorithms. Instead, the performance can be evaluated through benchmarks. <cit.> presents an algorithm to generate benchmarks of the qubit mapping problems on specific quantum processors along with optimal solutions. We have implemented the generating algorithm in Python. The input and output of the implementation are described below:

The set of qubit pairs which are available for 2-qubit gates is given by the edge set $E$ of a graph $G$. Given depth $d$, gate count $N$ and the proportion of 2-qubit gates $p_2$, a random quantum circuit which can be executed on the graph $G$ is generated along with an optimal qubit mapping of depth $d$.

Generation Script. An example of our implementation of QUEKO is shown below:

from QUEKO import QUEKO

edges = [(0, 1), (1, 2), (1, 3), (3, 4)]
prob = QUEKO(edges=edges, depth=5, gateCount=10, p2=0.3)

# print the generated OpenQASM program

# print the optimal solution, where the $i$-th qubit
# should be mapped to the $i$-th element of the list.
print("//" + prob.optimalMapping)

OpenQASM Code. A sample output of the above program is:

OPENQASM 2.0;
include "qelib1.inc";
qreg q[5];
cx q[1], q[2];
t q[4];
x q[1];
h q[0];
z q[3];
cx q[1], q[3];
y q[3];
cx q[4], q[2];
h q[3];
y q[2];

//[2, 3, 1, 4, 0]

Note that the gate cx q[4], q[2] is not available on the graph given by edges. However, if we apply the map

0 \mapsto 2,\ 1 \mapsto 3,\ 2\mapsto 1,\ 3\mapsto 4,\ 4\mapsto 0

to the qubits in the above program, all the $cx$ are then available on the graph.

§.§ Random Circuits

§.§.§ Random Clifford Circuits

Description. Clifford operation plays an important role in quantum error correction, randomized benchmarking protocols and quantum circuit simulation. By definition, Clifford operation is a unitary operation taking elements of \(G_n\) to elements of \(G_n\), where \(G_n\) is the Pauli group on \(n\) qubits. Any \(n\)-qubit Clifford operation can be simulated using \(O(n^2)\) Hadamard, phase and controlled-NOT gates. Clifford group elements are important and frequently encountered subsets of physical-level and fault-tolerant quantum circuits <cit.>, and sometimes an entire quantum algorithm can be a Clifford circuit (e.g., Bernstein–Vazirani <cit.>).

The Clifford group is a unitary 2-design. That is, a random uniformly distributed element of the Clifford group has exactly the same second order moments as the Haar random unitary operation. This means the random Clifford operations can serve as a substitute for Haar random unitaries in any application that depends only on the second order moments. In Qiskit, the random Clifford is sampled using the method of <cit.>. Then the Clifford circuit is synthesized by the method in <cit.> and optimized by the method in <cit.>.

Generation Script. The script for generating random Clifford circuit is as follows.

OpenQASM Code. The following gives a 3-qubit random Clifford circuit in OpenQASM 2.0 format.

§.§.§ Quantum Volume

Description. Quantum volume <cit.> is a metric that can be used to measure the capabilities and error rates of a quantum computer. It quantifies the largest random circuit of equal width and depth that the computer can successfully implement. The circuit model used for measuring quantum volume is as follows.

@C=1em @R=0em
5π     1SU(4)     5π     1SU(4)       ⋯    5π     1SU(4)

π            SU(4)            π            SU(4)              ⋯    π            SU(4)

π            1SU(4)     π            1SU(4)       ⋯    π            1SU(4)

π            SU(4)            π            SU(4)              ⋯    π            SU(4)

π            1SU(4)     π            1SU(4)       ⋯    π            1SU(4)

π            SU(4)            π            SU(4)              ⋯    π            SU(4)

The circuit model for quantum volume.

Here, $\pi$ is a permutation of qubits, and every $SU(4)$ represents a 2-qubit unitary gate sampled from the Haar measure on SU(4). There will be $d$ layers of this module if the depth of the circuit is $d$, and if the number of qubits in the circuit is odd, then every layer will have an idle qubit.

In our benchmark, we give a series of circuits for quantum volume constructed on basic quantum gates. And the $SU(4)$ gates are decomposed using qiskit.

OpenQASM Code. The following is an example of the quantum volume circuit with qubits 2 depth 2, and these circuits are decomposed to $cx$ and $u3$ gate using the standard QASM representation.

Generation Script. The script for generating circuit for arbitrary qubits and arbitrary depth is as follows.

[language = Python]files/Combinational_Cir/qv.py

§.§.§ Supremacy Circuits

Random circuits have been widely used in works related to the quantum supremacy <cit.>. Since there are already some benchmarks with such circuits, we just include the existing and commonly used circuits directly in our benchmark. One of such benchmark is GRCS [<https://github.com/sboixo/GRCS>]. GRCS provides a lot of random circuits, but all in a '.txt' format and not given in the standard OpenQASM language. In our benchmark, we give the OpenQASM version of the random circuits shown in GRCS.

§ DYNAMIC QUANTUM CIRCUITS

Dynamic quantum circuit is a model of quantum computation, in which quantum algorithms can be executed in a more flexible classical-quantum hybrid way, which can sometimes reduce the costs of quantum resources. The dynamic quantum circuit is adopted as an alternative and beneficial way for executing quantum algorithms on NISQ devices. Our benchmark includes a series of dynamic quantum circuits.

The biggest difference between dynamic quantum circuits and conventional quantum circuits is that measurements will usually appear in the middle of the circuit, and a series of classically controlled gates will be applied according to the results of the measurements.

§.§ Quantum Teleportation

Description. One of the simplest examples of dynamic quantum circuits is teleportation. Teleportation is a protocol for transmitting a qubit between two users by sending two classical bits of information <cit.>.

OpenQASM Code.  The corresponding circuit and the OpenQASM 2.0 description are as follows. The first qubit belongs to Alice and the last qubit belongs to Bob. By first applying a series of quantum gates and sending the measurement result to Bob, Bob can obtain the state of the first qubit of Alice by applying a series of gates according to the measurement information.

@C=.7em @R=.2em @!
|φ⟩             1    H

|0⟩           H     -1             X     Z       |φ⟩

Dynamic quantum circuit for Teleportation.

§.§ Semiclassical Fourier Transform

Description. The quantum Fourier transform can also be represented as a dynamic quantum circuit form <cit.>. The following gives the detailed information of the dynamic version of the quantum Fourier transform. From Figure <ref> and Figure <ref> you can see that all the controlled-$R_k$ gates are replaced by a measurement and classically controlled $R_k$ gates.

@C=0.7em @R=0.4em
|j_1⟩      H    [1]

|j_2⟩         R_2       H       [1]

|j_3⟩               R_3   R_2       H

Dynamic quantum circuit for Fourier transform.

The advantage of using this dynamic quantum circuit is that there is no need to apply 2-qubit gates during the process, all the 2-qubit gates can be replaced by single-qubit gates chosen according to the measurement results.

OpenQASM Code. Following gives the OpenQASM description of the dynamic version of quantum Fourier transform.

Generation Script. Similar to the conventional quantum circuit, the corresponding circuit can be generated as follows.

[language = Python]files/dqcircuit/dqc_qft.py

§.§ Iterative Phase Estimation

Description. Since the quantum phase estimation uses the inverse quantum Fourier transform as a subroutine, it can also be executed as a dynamic quantum circuit. The dynamic version of quantum phase estimation is as follows.

@C=0.7em @R=0.4em
|0⟩      H       2     H

|0⟩      H    1          R_2^†    H

|φ⟩     /   U    U^2

Quantum circuit for phase estimation.

The advantage of the phase estimation implemented by the dynamic quantum circuit is that the circuit can be executed with only 2-qubit gates, and more details are shown in <cit.>.

OpenQASM Code.  The following gives the dynamic version of 3-qubit phase estimation.

Generation Script.  The code for generating dynamic quantum phase estimation circuit of any qubit number is as follows.

[language = Python]files/dqcircuit/dqc_pe.py

§.§ Quantum Error correction

Description. Another example of dynamic quantum circuits is the circuit for quantum error correction, where a quantum state must first experience a period of syndrome measurement, and then be recovered according to the measurement result.

OpenQASM Code.  The following gives the circuit model of error correction as well as the OpenQASM 2.0 description of the bit-flip and phase-flip code <cit.>.

@C=1.3em @R=.6em
2 ℛ

2     3

3          ℛ

A circuit model for Quantum Error correction.

§.§ State Injection

Description. State injection is the technique for implementing some quantum gates using a dynamic scheme. The basic idea is that the effect of this gate can be implemented by using a special state and a series of gates that can be implemented more simply.

OpenQASM Code.  The following gives the circuit and the OpenQASM scripts for the dynamic implementation of the $S$ and $T$ gate <cit.>.

@C=1.3em @R=.6em
|ψ⟩           1    Z        S|ψ⟩

@C=1.3em @R=.6em
|ψ⟩           1    S        T|ψ⟩

The quantum circuits for state injection, (a) implementation of $S$ gate, (b) implementation of $T$ gate.

§ SEQUENTIAL QUANTUM CIRCUITS

Sequential quantum circuits <cit.> are a new breed of quantum circuits that incorporate a clock signal.
They can be understood as a generalization of classical (synchrounous) logic circuits.
From another point of view, sequential quantum circuits are a special type of dynamic quantum circuits, since intermediate measurements are intended to perform at the end of each time step.

Sequential quantum circuits are useful in describing algorithms with loops and quantum feedback, e.g., Repeat-Until-Success circuits <cit.> and quantum walks <cit.>.
In this section, we select some of the examples of sequential quantum circuits and explain how we benchmark them in OpenQASM.

§.§ Repeat-Until-Success

Description. Repeat-Until-Success circuits <cit.> are a bunch of efficient implementations of quantum logic gates which make good use of intermediate measurements as feedback.
Figure <ref> shows a sequential quantum circuit for repeat-until-success implementation of quantum gate

\[
V_3 = \frac{I + 2iZ}{\sqrt{5}}.
\]

On this basis, we design several benchmarks.

\begin{equation*}\qquad \quad
\Qcircuit @C=.6em @R=.6em {
\lstick{q = \ket 0}    & \qw & \qw & \qw   & \qw & \gate{H} & \gate{T} & \gate{H} & \ctrl{1}     & \gate{T^\dag} & \gate{H} & \gate{T} & \ctrl{1}     & \gate{H} & \gate{T} & \gate{H} & \qw & \meter    & \cw  \\
\lstick{p = \ket \psi} &     & \qw & \qw > & \qw & \qw      & \qw      & \qw      & \gate{Z}     & \qw           & \qw      & \qw      & \gate{Z}     & \gate{Z} & \qw      & \qw      & \qw & \qw \\
& \qwx  & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \qw \qwx
\gategroup{1}{6}{2}{16}{1.5em}{--}
\end{equation*}

A sequential quantum circuit for repeat-until-success implementation of $V_3$. This figure is taken from <cit.>.

OpenQASM Code. In Figure <ref>, $q$ is the only input variable (qubit) while $p$ is the only internal variable (qubit). At each time step, the qubit $q$ will be measured in the computational basis indicating whether the implementation succeeds. We abstract the main process of the repeat-until-success implementation of $V_3$ in OpenQASM as follows.

Next, we will show how to use the function above to execute the sequential quantum circuit for one time step.
Before the main process of the sequential circuit, we need to initialize the internal variable, which is qubit $p$ in our case. The following code sets $p$ to $\ket{+}$.

Every time before calling the function , we need to prepare input qubit $q$ beforehand.

Now we are ready to call .

After calling , you can  obtain the measurement outcome of the sequential quantum circuit as follows.

Here, we note that qubit $q$ has already been measured in the execution of  before that of . Nevertheless, the measurement outcome is always retrieved from a correct probability distribution. The reason we encapsulate measurements in the main process of the sequential circuit (i.e.,  in our case) is to ensure that a measurement must be performed at each time step.

§.§.§ qrus-1

Test case “qrus-1” consists of two examples <qrus-1.a.qasm> and <qrus-1.b.qasm>, whose combinational quantum circuits are both based on Figure <ref>. Their initial internal states are

\[
\ket{\psi_0^a} = \ket{0}
\]

\[
\ket{\psi_0^b} = \ket{+} = \frac{\ket{0}+\ket{1}}{\sqrt{2}},
\]

respectively. The two examples are designed to be equivalent.

§.§.§ qrus-2

Test case “qrus-2” consists of two examples <qrus-2.a.qasm> and <qrus-2.b.qasm>, whose combinational quantum circuits are both based on Figure <ref>. Their initial internal states are

\[
\ket{\psi_0^a} = \frac{\ket{0} + i\ket{1}}{\sqrt{2}},
\]

\[
\ket{\psi_0^b} = \frac{\ket{0} + 2\ket{1}}{\sqrt{5}},
\]

respectively. The two examples are designed to be equivalent.

§.§ Quantum Walk

Description. Quantum walks <cit.> are quantum generalizations of classical random walks, and have many applications in quantum algorithms. As an illustrative example (see Figure <ref>), we consider a quantum walk on a circle (with positions $\ket{0}_p, \ket{1}_p, \ket{2}_p, \ket{3}_p$) with an absorbing boundary $\ket{3}_p$. Here, $\mathit{Toss}$ is the toss operator

\begin{align*}
\mathit{Toss}:
& \ket{0}_c \ket{i}_p \to \ket{0}_c \ket{\left(i+1\right) \bmod 4}_p, \\
& \ket{1}_c \ket{i}_p \to \ket{1}_c \ket{\left(i-1\right) \bmod 4}_p,
\end{align*}

which translates the position conditioned on the coin state.

\begin{equation*}
\Qcircuit @C=1.2em @R=0.9em {
\lstick{d}            & \qw & \qw & \qw & \qw & \qw         & \qw               & \targ     & \qw & \meter    & \cw  \\
\lstick{c}        &     & \qw & \qw & \qw > & \gate{H}    & \multigate{2}{\mathit{Toss}}  & \qw       & \qw       & \qw & \qw  \\
\lstick{p_1}  & \qwx&     & \qw & \qw > & \qw         & \ghost{\mathit{Toss}}         & \ctrl{-2} & \qw       & \qw & \qwx\\
\lstick{p_2}  & \qwx& \qwx&     & \qw > & \qw         & \ghost{\mathit{Toss}}         & \ctrl{-3} & \qw       & \qwx& \qwx \\
& \qwx& \qwx& \qwx& \qw & \qw         & \qw               & \qw       & \qw \qwx  & \qwx&\qwx \\
& \qwx& \qwx& \qw & \qw & \qw         & \qw               & \qw       & \qw       & \qw \qwx&\qwx \\
& \qwx& \qw & \qw & \qw & \qw         & \qw               & \qw       & \qw       & \qw & \qw \qwx
\gategroup{1}{6}{4}{8}{1.8em}{--}
\end{equation*}

A sequential quantum circuit for quantum walk. This figure is taken from <cit.>.

OpenQASM Code. In Figure <ref>, $d$ is the only input variable (qubit), and $c, p_1, p_2$ are the output variables (qubits). The OpenQASM code for the sequential quantum circuit in Figure <ref> is as follows.

Similar to the use of the code in repeat-until-success circuits, after initializing qubit $d$, a call to $\texttt{qwalk(d, c, p1, p2)}$ will result in one step of quantum walk.

§.§ Classical Control

Description. For the convenience to control the behaviour of quantum systems, we consider a class of sequential quantum circuits with their input variables in the computational basis. For example, in Figure <ref>, the input variables $q_1$ and $q_2$ control which kind of quantum gates is performed on $p_1, p_2, p_3$. In order to retrieve some information from the sequential quantum circuit, we use a detective qubit (an input variable) $d$ with it being initialized to $\ket{0}$.

\begin{equation*}
\Qcircuit @C=1.2em @R=.9em {
\lstick{d = \ket{0}}            & \qw & \qw & \qw & \qw   & \qw       & \qw       & \qw       & \qw       & \targ     & \qw & \meter    & \cw  \\
\lstick{q_1}                & \qw & \qw & \qw & \qw   & \ctrl{1}  & \ctrlo{1} & \ctrlo{1} & \ctrl{1}  & \qw       & \qw & \meter    & \cw  \\
\lstick{q_2}                & \qw & \qw & \qw & \qw   & \ctrl{1}  & \ctrlo{1} & \ctrl{2}  & \ctrlo{3} & \qw       & \qw & \meter    & \cw  \\
\lstick{p_1}                &     & \qw & \qw & \qw > & \ctrl{1}  & \gate{H}  & \qw       & \qw       & \ctrl{-3} & \qw       & \qw & \qw  \\
\lstick{p_2}                & \qwx&     & \qw & \qw > & \ctrl{1}  & \qw       & \gate{H}  & \qw       & \qw       & \qw       & \qw & \qwx\\
\lstick{p_3}                & \qwx& \qwx&     & \qw > & \targ     & \qw       & \qw       & \gate{H}  & \qw       & \qw       & \qwx& \qwx \\
& \qwx& \qwx& \qwx& \qw   & \qw       & \qw       & \qw       & \qw       & \qw       & \qw \qwx  & \qwx&\qwx \\
& \qwx& \qwx& \qw & \qw   & \qw       & \qw       & \qw       & \qw       & \qw       & \qw       & \qw \qwx&\qwx \\
& \qwx& \qw & \qw & \qw   & \qw       & \qw       & \qw       & \qw       & \qw       & \qw       & \qw & \qw \qwx
\gategroup{1}{6}{6}{10}{1.0em}{--}
\end{equation*}

A sequential quantum circuit for classical control. This figure is taken from <cit.>.

OpenQASM Code. The OpenQASM code for the sequential quantum circuit in Figure <ref> is as follows.

After initializing input variables $d, q_1, q_2$, we can call  for one time step of the computation.

§ VARIATIONAL QUANTUM CIRCUITS

The benchmark on variational quantum circuits (VQCs, or parameterized quantum circuits) aims to provide VQC templates of variational quantum algorithms, including variational quantum eigensolver (VQE).

§.§ Variational Quantum Eigensolver

Description. Solving the ground state energy (minimum eigenvalue) of a Hamiltonian is fundamental in quantum chemistry and condensed matter physics.
By using various VQCs to model wavefunctions, VQE converts the minimum eigenvalue problem into optimization over parameters of VQCs. The reader can refer to a review <cit.> for comprehensive knowledge.

Generation Script. In the benchmark, we provide a Python script named BenchmarkVQE.py to generate OpenQASM files for VQCs used in VQE literature.
The different types of VQCs (ansatz) we currently support and the corresponding arguments are as follows:

* Hardware-efficient ansatz, –ansatz hea.

* Unitary coupled cluster (UCC) ansatz, –ansatz ucc.

* Symmetry-preserving ansatz, –ansatz spa.

After specifying the ansatz, there are some arguments (e.g., number of qubits) left to set. For detailed usage, please refer to our repository in GitHub.

For example, the following command

python benchmark_vqe.py –ansatz hea –num_qubits 2

will generate an OpenQASM file output.qasm for hardware-efficient ansatz with $2$ qubits and all parameters randomly.

OpenQASM Code. An example is as follows.

§ VALIDATION

All our benchmark circuits are validated by Qiskit <cit.> and QCOR <cit.>. For OpenQASM 2.0 descriptions, Qiskit is used. To run an example named in_file.qasm, simply navigate to its directory and execute the codes in python:

qc = qiskit.QuantumCircuit.from_qasm_file('./in_file.qasm')
simulator = qiskit.Aer.get_backend('aer_simulator')
qc = qiskit.transpile(qc,simulator)
result = simulator.run(qc, shots=1, memory=True).result()

For OpenQASM 3.0 descriptions, QCOR is used. To run an example named in_file.qasm, simply navigate to its directory and execute:

qcor -shots 1024 in_file.qasm

The simulation can be accelerated using TNQVM <cit.>, which leverages tensor network theory to simulate quantum circuits. To run the above example with TNQVM acceleration, simply execute:

qcor -qpu tnqvm[tnqvm-visitor:exatn] -shots 1024 in_file.qasm

For more details, we refer the readers to the official documentation and user guides <cit.>.

§ EXAMPLE APPLICATIONS

To demonstrate the utility, in this section, we discuss some  example applications and point out how the benckmark circuits of VeriQBench are used there. A summary of these applications is presented in Table <ref>.

Example Applications

Example Applications     Used VeriQBench Benchmark Circuits

Equivalence Checking <cit.>     QFT, Grover, Dynamic (Section <ref>)

Fault Simulation     BV, QFT

Circuit Optimization <cit.>     QFT, Reversible (Section <ref>)

ATPG <cit.>     Grover, BV, QFT, QV

Qubit Mapping <cit.>     Generated Circuits (Section <ref>)

Model Checking <cit.>     Teleportation

* Equivalence Checking of Quantum Circuits: Equivalence checking is to check if two quantum circuits are functionally equivalent <cit.>. The circuits for quantum Fourier transform and Grover's algorithms have been used in work  <cit.> to demonstrate the effectiveness of their equivalence checking methods. Also, the  circuits given in Section <ref> have been used in testing the algorithm developed in <cit.> for checking equivalence of dynamic quantum circuits, and the circuits such as Bernstein-Vazirani and quantum Fourier transform and quantum volume have been used in the approximate equivalence checking of noisy quantum circuits <cit.>.
The circuits given in Section <ref> have been used in equivalence checking of sequential quantum circuits <cit.>.

* Fault Simulation of Quantum Circuits: Given a quantum circuit and its faulty implementation, fault simulation is to calculate the fidelity between the expected output state and the actually obtained output state <cit.>. The work is performed on combinational quantum circuits, including Bernstein-Vazirani and Quantum Fourier Transform with realistic fault models proposed in <cit.>.

* Circuit Optimization: Quantum circuit optimization <cit.> aims to reduce the complexity of a quantum circuit, where the complexity, depending on the scenario, can be quantified by the size, depth, T-count or T-depth of the quantum circuit. The reversible circuits such as divisibility checkers have been used to benchmark the quantum circuit optimization algorithms <cit.>.

* Automatic Test Pattern Generation (ATPG): Quantum ATPG algorithms <cit.> aim to generate specific test patterns based on the structure and fault model of the quantum circuit,
where the test patterns include a set of input vectors and corresponding outputs vectors. The Combinational Quantum Circuits including Grover's algorithm, Bernstein-Vazirani, Quantum Fourier Transform and Quantum Volume with the unitary fault model have been used to demonstrate the effectiveness of the ATPG algorithms in <cit.>.

* Qubit Mapping: The target of qubit mapping is to assign a physical qubit on a quantum chip to every logical qubit in a quantum circuit, while optimizing the performance of the circuit  <cit.>. One of the most important performance metrics of quantum circuits is the depth of the circuit. The method for generating qubit mapping problems with optimal solutions for depth in this benchmark was proposed in <cit.>, and was used to evaluate the qubit mapping tools in <cit.>.

* Model Checking Quantum Systems: Model-checking is one of the most successful verification techniques with numerous applications in hardware and software industries. It has been generalised to check various properties of quantum systems, including quantum cryptographic protocols <cit.>, quantum programs <cit.> and quantum circuits <cit.>.  The teleportation circuit in Section <ref> has been used in probabilistic model checking algorithm of quantum protocols <cit.>.

§ ACKNOWLEDGMENTS

We would like to thank Zhicheng Zhang, Minbo Gao and Riling Li for their insightful discussions. This work was partly supported by the National Key R&D Program of China (Grant No: 2018YFA0306701), the National Natural Science Foundation of China (Grant No: 61832015).

Missing 'biblatex' package
The bibliography requires the 'biblatex' package.

journaltitleGoogle Scholar Google Scholar Digital Library Digital Library
titleReversible and Quantum Circuits

journaltitlePhysical Review A
titleQuantum random walks

journaltitlePhysical Review A
titleImproved simulation of stabilizer circuits

titleAIDE-QC: Documentation and User Guides

booktitleProceedings of the Thirty-Third Annual ACM Symposium on Theory of Computing
titleOne-dimensional quantum walks

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titlePolynomial-time T-depth optimization of Clifford+ T circuits via matroid partitioning

Nature Publishing Group

titleQuantum supremacy using a programmable superconducting processor

journaltitlePhysical review letters
titleTeleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleDetection and diagnosis of single faults in quantum circuits

booktitle2019 IEEE/ACM International Conference on Computer-Aided Design (ICCAD)
titleMUQUT: Multi-constraint quantum circuit mapping on NISQ computers

journaltitleIEEE Transactions on Information Theory
titleHadamard-free circuits expose the structure of the Clifford group

Nature Publishing Group

journaltitleNature Physics
titleCharacterizing quantum supremacy in near-term devices

journaltitlearXiv preprint arXiv:2105.02291
titleClifford circuit optimization with templates and symbolic pauli gates

journaltitlearXiv preprint arXiv:2003.02989
titleTensorflow quantum: A software framework for quantum machine learning

journaltitleSIAM Journal on Computing
titleQuantum complexity theory

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleAdvanced equivalence checking for quantum circuits

booktitle2020 25th Asia and South Pacific Design Automation Conference (ASP-DAC)
titleImproved DD-based equivalence checking of quantum circuits

Nature Publishing Group

journaltitleNature Reviews Physics
titleVariational quantum algorithms

American Physical Society

journaltitlePhys. Rev. Research
titleSimulating noisy quantum circuits with matrix product density operators

journaltitleLecture notes at University of Maryland
titleLecture notes on quantum algorithms

journaltitlePhysical Review Letters
titleExploiting dynamic quantum circuits in a quantum algorithm with superconducting qubits

journaltitlePhysical Review A
titleValidating quantum computers using randomized model circuits

booktitle2008 International Conference on Electronic Design
titleDesigning quantum adder circuits and evaluating their error performance

journaltitlearXiv preprint arXiv:1902.09102
titleCircuit transformations for quantum architectures

journaltitlearXiv preprint arXiv:2202.10697
titleAutomatic Test Pattern Generation for Robust Quantum Circuit Testing

journaltitlePhysical Review A
titleRandom circuit block-encoded matrix and a proposal of quantum LINPACK benchmark

journaltitlearXiv preprint arXiv:1411.4028
titleA quantum approximate optimization algorithm

journaltitlePhysical Review Letters
titleSemiclassical Fourier transform for quantum computation

journaltitlearXiv preprint quant-ph/0504007
titleProbabilistic Model–Checking of Quantum Protocols

booktitleInternational Conference on Computer Aided Verification
titleQMC: A model checker for quantum systems

booktitleProceedings of the twenty-eighth annual ACM symposium on Theory of computing
titleA fast quantum mechanical algorithm for database search

Multidisciplinary Digital Publishing Institute

titleFrom the quantum approximate optimization algorithm to a quantum alternating operator ansatz

booktitle2021 58th ACM/IEEE Design Automation Conference (DAC)
titleApproximate equivalence checking of noisy quantum circuits

journaltitlearXiv preprint arXiv:2106.01658
titleEquivalence Checking of Dynamic Quantum Circuits

booktitle2020 57th ACM/IEEE Design Automation Conference (DAC)
titleRealistic Fault Models and Fault Simulation for Quantum Dot Quantum Circuits

titleFault Simulation Repository

Virtual, USA

Association for Computing Machinery

booktitleProceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems
seriesASPLOS 2021
titleLogical Abstractions for Noisy Variational Quantum Algorithm Simulation
quantum circuits,Bayesian networks,exact inference,conjunctive normal form,simulation,knowledge compilation

titleSimulations of Quantum Circuits with Approximate Noise using qsim and Cirq
Quantum Physics (quant-ph),FOS: Physical sciences,FOS: Physical sciences

journaltitleContemporary Physics
titleQuantum random walks: an introductory overview

booktitleProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems
titleTackling the qubit mapping problem for NISQ-era quantum devices

journaltitlearXiv preprint arXiv:2005.13018
titleQasmbench: A low-level qasm benchmark suite for nisq evaluation and simulation

ACM New York, NY, USA

journaltitleProceedings of the ACM on Programming Languages
titleProjection-based runtime assertions for testing and debugging quantum programs

journaltitlearXiv preprint arXiv:2105.05232
titleBenchmarking near-term quantum computers via random circuit sampling

booktitleProceedings of the 39th International Symposium on Multiple-Valued Logic
titleQuantum Finite State Machines as Sequential Quantum Circuits

journaltitleIEEE Transactions on Very Large Scale Integration (VLSI) Systems
titlePAQCS: Physical design-aware fault-tolerant quantum circuit synthesis

titleReversible Logic Synthesis Benchmarks Page

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleQuantum circuit simplification and level compaction

Public Library of Science

journaltitlePLOS ONE
titleValidating quantum-classical programming models with tensor network simulations

booktitle2019 ACM/IEEE 46th Annual International Symposium on Computer Architecture (ISCA)
titleFull-stack, real-system quantum computer studies: Architectural comparisons and design insights

Nature Publishing Group

journaltitlenpj Quantum Information
titleAutomated optimization of large quantum circuits with continuous parameters

American Association of Physics Teachers

titleQuantum computation and quantum information

journaltitlearXiv e-prints
titleExtending C++ for Heterogeneous Quantum-Classical Computing
Quantum Physics,Computer Science - Mathematical Software

Nature Publishing Group

journaltitleNature communications
titleA variational eigenvalue solver on a photonic quantum processor

booktitle17th Asia and South Pacific Design Automation Conference
titleDetection and diagnosis of faulty quantum circuits

ACM New York, NY, USA

journaltitleACM Journal on Emerging Technologies in Computing Systems (JETC)
titleData structures and algorithms for simplifying reversible circuits

journaltitleQuantum Information & Computation
titleRepeat-until-success: non-deterministic decomposition of single-qubit unitaries

journaltitleIEEE Circuits and Systems Magazine
titleLayout optimization for quantum circuits with linear nearest neighbor architectures

AIP Publishing LLC

journaltitleReview of Scientific Instruments
titleHardware for dynamic quantum computing

booktitleProceedings of the 2018 International Symposium on Code Generation and Optimization
titleQubit allocation

IOP Publishing

journaltitleQuantum Science and Technology
titlet| ket>: a retargetable compiler for NISQ devices

ACM New York, NY, USA

journaltitleACM Computing Surveys (CSUR)
titleSynthesis and optimization of reversible circuits—a survey

booktitle2014 19th Asia and South Pacific Design Automation Conference (ASP-DAC)
titleQubit placement to minimize communication overhead in 2D quantum architectures

booktitle2020 IEEE/ACM International Conference On Computer Aided Design (ICCAD)
titleOptimal layout synthesis for quantum computing

journaltitleIEEE Transactions on Computers
titleOptimality study of existing quantum computing layout synthesis tools

titleThe Variational Quantum Eigensolver: a review of methods and best practices

journaltitlearXiv preprint arXiv:2202.11045
titleSupermarQ: A Scalable Quantum Benchmark Suite

booktitleProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems
titleNot all qubits are created equal: a case for variability-aware policies for NISQ-era quantum computers

booktitle2007 IEEE/ACM International Conference on Computer-Aided Design
titleChecking equivalence of quantum circuits and states

booktitle2019 56th ACM/IEEE Design Automation Conference (DAC)
titleMapping quantum circuits to IBM QX architectures using the minimal number of SWAP and H operations

booktitle2014 19th Asia and South Pacific Design Automation Conference (ASP-DAC)
titleOptimal SWAP gate insertion for nearest neighbor quantum circuits

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleEquivalence Checking of Sequential Quantum Circuits
pagesEarly Access

Cambridge University Press

titleModel Checking Quantum Systems: Principles and Algorithms

booktitleInternational Symposium on Formal Methods
titleModel Checking for Verification of Quantum Circuits

booktitle2010 IEEE/ACM International Symposium on Nanoscale Architectures
titleFast equivalence-checking for quantum circuits

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleAn efficient methodology for mapping quantum circuits to the IBM QX architectures

Missing 'biblatex' package
The bibliography requires the 'biblatex' package.

journaltitleGoogle Scholar Google Scholar Digital Library Digital Library
titleReversible and Quantum Circuits

journaltitlePhysical Review A
titleQuantum random walks

journaltitlePhysical Review A
titleImproved simulation of stabilizer circuits

titleAIDE-QC: Documentation and User Guides

booktitleProceedings of the Thirty-Third Annual ACM Symposium on Theory of Computing
titleOne-dimensional quantum walks

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titlePolynomial-time T-depth optimization of Clifford+ T circuits via matroid partitioning

Nature Publishing Group

titleQuantum supremacy using a programmable superconducting processor

journaltitlePhysical review letters
titleTeleporting an unknown quantum state via dual classical and Einstein-Podolsky-Rosen channels

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleDetection and diagnosis of single faults in quantum circuits

booktitle2019 IEEE/ACM International Conference on Computer-Aided Design (ICCAD)
titleMUQUT: Multi-constraint quantum circuit mapping on NISQ computers

journaltitleIEEE Transactions on Information Theory
titleHadamard-free circuits expose the structure of the Clifford group

Nature Publishing Group

journaltitleNature Physics
titleCharacterizing quantum supremacy in near-term devices

journaltitlearXiv preprint arXiv:2105.02291
titleClifford circuit optimization with templates and symbolic pauli gates

journaltitlearXiv preprint arXiv:2003.02989
titleTensorflow quantum: A software framework for quantum machine learning

journaltitleSIAM Journal on Computing
titleQuantum complexity theory

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleAdvanced equivalence checking for quantum circuits

booktitle2020 25th Asia and South Pacific Design Automation Conference (ASP-DAC)
titleImproved DD-based equivalence checking of quantum circuits

Nature Publishing Group

journaltitleNature Reviews Physics
titleVariational quantum algorithms

American Physical Society

journaltitlePhys. Rev. Research
titleSimulating noisy quantum circuits with matrix product density operators

journaltitleLecture notes at University of Maryland
titleLecture notes on quantum algorithms

journaltitlePhysical Review Letters
titleExploiting dynamic quantum circuits in a quantum algorithm with superconducting qubits

journaltitlePhysical Review A
titleValidating quantum computers using randomized model circuits

booktitle2008 International Conference on Electronic Design
titleDesigning quantum adder circuits and evaluating their error performance

journaltitlearXiv preprint arXiv:1902.09102
titleCircuit transformations for quantum architectures

journaltitlearXiv preprint arXiv:2202.10697
titleAutomatic Test Pattern Generation for Robust Quantum Circuit Testing

journaltitlePhysical Review A
titleRandom circuit block-encoded matrix and a proposal of quantum LINPACK benchmark

journaltitlearXiv preprint arXiv:1411.4028
titleA quantum approximate optimization algorithm

journaltitlePhysical Review Letters
titleSemiclassical Fourier transform for quantum computation

journaltitlearXiv preprint quant-ph/0504007
titleProbabilistic Model–Checking of Quantum Protocols

booktitleInternational Conference on Computer Aided Verification
titleQMC: A model checker for quantum systems

booktitleProceedings of the twenty-eighth annual ACM symposium on Theory of computing
titleA fast quantum mechanical algorithm for database search

Multidisciplinary Digital Publishing Institute

titleFrom the quantum approximate optimization algorithm to a quantum alternating operator ansatz

booktitle2021 58th ACM/IEEE Design Automation Conference (DAC)
titleApproximate equivalence checking of noisy quantum circuits

journaltitlearXiv preprint arXiv:2106.01658
titleEquivalence Checking of Dynamic Quantum Circuits

booktitle2020 57th ACM/IEEE Design Automation Conference (DAC)
titleRealistic Fault Models and Fault Simulation for Quantum Dot Quantum Circuits

titleFault Simulation Repository

Virtual, USA

Association for Computing Machinery

booktitleProceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems
seriesASPLOS 2021
titleLogical Abstractions for Noisy Variational Quantum Algorithm Simulation
quantum circuits,Bayesian networks,exact inference,conjunctive normal form,simulation,knowledge compilation

titleSimulations of Quantum Circuits with Approximate Noise using qsim and Cirq
Quantum Physics (quant-ph),FOS: Physical sciences,FOS: Physical sciences

journaltitleContemporary Physics
titleQuantum random walks: an introductory overview

booktitleProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems
titleTackling the qubit mapping problem for NISQ-era quantum devices

journaltitlearXiv preprint arXiv:2005.13018
titleQasmbench: A low-level qasm benchmark suite for nisq evaluation and simulation

ACM New York, NY, USA

journaltitleProceedings of the ACM on Programming Languages
titleProjection-based runtime assertions for testing and debugging quantum programs

journaltitlearXiv preprint arXiv:2105.05232
titleBenchmarking near-term quantum computers via random circuit sampling

booktitleProceedings of the 39th International Symposium on Multiple-Valued Logic
titleQuantum Finite State Machines as Sequential Quantum Circuits

journaltitleIEEE Transactions on Very Large Scale Integration (VLSI) Systems
titlePAQCS: Physical design-aware fault-tolerant quantum circuit synthesis

titleReversible Logic Synthesis Benchmarks Page

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleQuantum circuit simplification and level compaction

Public Library of Science

journaltitlePLOS ONE
titleValidating quantum-classical programming models with tensor network simulations

booktitle2019 ACM/IEEE 46th Annual International Symposium on Computer Architecture (ISCA)
titleFull-stack, real-system quantum computer studies: Architectural comparisons and design insights

Nature Publishing Group

journaltitlenpj Quantum Information
titleAutomated optimization of large quantum circuits with continuous parameters

American Association of Physics Teachers

titleQuantum computation and quantum information

journaltitlearXiv e-prints
titleExtending C++ for Heterogeneous Quantum-Classical Computing
Quantum Physics,Computer Science - Mathematical Software

Nature Publishing Group

journaltitleNature communications
titleA variational eigenvalue solver on a photonic quantum processor

booktitle17th Asia and South Pacific Design Automation Conference
titleDetection and diagnosis of faulty quantum circuits

ACM New York, NY, USA

journaltitleACM Journal on Emerging Technologies in Computing Systems (JETC)
titleData structures and algorithms for simplifying reversible circuits

journaltitleQuantum Information & Computation
titleRepeat-until-success: non-deterministic decomposition of single-qubit unitaries

journaltitleIEEE Circuits and Systems Magazine
titleLayout optimization for quantum circuits with linear nearest neighbor architectures

AIP Publishing LLC

journaltitleReview of Scientific Instruments
titleHardware for dynamic quantum computing

booktitleProceedings of the 2018 International Symposium on Code Generation and Optimization
titleQubit allocation

IOP Publishing

journaltitleQuantum Science and Technology
titlet| ket>: a retargetable compiler for NISQ devices

ACM New York, NY, USA

journaltitleACM Computing Surveys (CSUR)
titleSynthesis and optimization of reversible circuits—a survey

booktitle2014 19th Asia and South Pacific Design Automation Conference (ASP-DAC)
titleQubit placement to minimize communication overhead in 2D quantum architectures

booktitle2020 IEEE/ACM International Conference On Computer Aided Design (ICCAD)
titleOptimal layout synthesis for quantum computing

journaltitleIEEE Transactions on Computers
titleOptimality study of existing quantum computing layout synthesis tools

titleThe Variational Quantum Eigensolver: a review of methods and best practices

journaltitlearXiv preprint arXiv:2202.11045
titleSupermarQ: A Scalable Quantum Benchmark Suite

booktitleProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems
titleNot all qubits are created equal: a case for variability-aware policies for NISQ-era quantum computers

booktitle2007 IEEE/ACM International Conference on Computer-Aided Design
titleChecking equivalence of quantum circuits and states

booktitle2019 56th ACM/IEEE Design Automation Conference (DAC)
titleMapping quantum circuits to IBM QX architectures using the minimal number of SWAP and H operations

booktitle2014 19th Asia and South Pacific Design Automation Conference (ASP-DAC)
titleOptimal SWAP gate insertion for nearest neighbor quantum circuits

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleEquivalence Checking of Sequential Quantum Circuits
pagesEarly Access

Cambridge University Press

titleModel Checking Quantum Systems: Principles and Algorithms

booktitleInternational Symposium on Formal Methods
titleModel Checking for Verification of Quantum Circuits

booktitle2010 IEEE/ACM International Symposium on Nanoscale Architectures
titleFast equivalence-checking for quantum circuits

journaltitleIEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
titleAn efficient methodology for mapping quantum circuits to the IBM QX architectures