# sQueeze: Accelerated Quantum Pulse Schedules

Lilian Hunt  School of Computer Science
University of Sydney and  Alan Robertson  School of Computer Science
University of Sydney

###### Abstract.

Quantum devices in the Noisy Intermediate-Scale Quantum (NISQ) era are limited
by high error rates and short decoherence times. Typically, compiler
optimisations have provided solutions at the gate level. Alternatively, we
exploit the finest level of quantum control and introduce a set of pulse level
quantum compiler optimisations: sQueeze. Instead of relying on existing
calibration that may be inaccurate, we provide a method for the live
calibration of two new parameterised basis gates $R_{x}(\theta)$ and
$R_{zx}(\theta)$ using an external server. We validate our techniques using
the IBM quantum devices and the OpenPulse control interface over more than 8
billion shots. The $R_{x}(\theta)$ gates are on average 52.7% more accurate
than their current native Qiskit decompositions, while $R_{zx}(\theta)$ are
22.6% more accurate on average. These more accurate pulses also provide up to
a 4.1$\times$ speed-up for single-qubit operations and 3.1$\times$ speed-up
for two-qubit gates. Then sQueeze demonstrates up to a 39.6% improvement in
the fidelity of quantum benchmark algorithms compared to conventional
approaches.

††copyright: none

##  Introduction

Quantum computation may one day lead to essential applications in quantum
chemistry (moll2018quantum, ), finance (orus2019quantum, ; egger2020quantum,
), optimisation (farhi2014quantum, ; egger2021warm, ), and machine learning
(biamonte2017quantum, ; havlivcek2019supervised, ). In contrast with the
advantages promised by fault-tolerant quantum computation, modern ‘NISQ’
devices are limited by high error rates, short decoherence times and low qubit
counts (preskill2018quantum, ). To realise the potential of quantum computing
improvements are needed from the algorithmic level to the finest level of
hardware control. For current transmon devices this control is expressed as
sequences of parameterised ‘pulses’ (alexander2020qiskit, ).

While quantum algorithms require arbitrary precision operations, these
operations must be implemented relative to a finite number of calibrated
control operations for each quantum device. To achieve this, logical
operations must be decomposed into a sequence of basis gates, where only basis
gates have a direct implementation on the device as a series of pulses. This
decomposition to a sequence of basis gates is computationally non-trivial.
Techniques have progressed from exhaustive searches (fowler2004constructing, ;
kliuchnikov2015practical, ), to limited depth searches (dawson2005solovay, ),
normal forms (bocharov2012resource, ; matsumoto2008representation, ), and
heuristic-based approaches (davis2020towards, ; mooney2021cost, ). Pulse
control started with brute-force optimization of a few pulse parameters
(jakubetz1990mechanism, ) and has advanced to Quantum Optimal Control (QOC)
(de2011second, ; glaser2015training, ; krotov1995global, ). However, most
noisy experimental systems are not ready for QOC methods
(gokhale2020optimized, ). In addition to long compilation times, QOC depends
on accurate models of the analogue pulses and the device Hamiltonian, which
are difficult to determine experimentally and may fluctuate over short periods
of time.

Methods focusing on both gate and pulse optimisations have shown that adding
parameterised operations at the pulse level reduce gate decomposition depth
significantly (foxen2020demonstrating, ). To avoid calibration costs, recent
work has scaled the pulses calibrated by the device providers
(earnest2021pulse, ; gokhale2020optimized, ). However, our work has shown that
the inferred pulse models are not necessarily a good approximation and rely on
existing gate calibrations that may be inaccurate, especially for current
noisy devices. Experiments conducted over five months show that current IBM
quantum devices exhibit significant amounts of noise and that a single
calibration snapshot is not necessarily a good representation of the average
device behaviour.

@C=1em @R=.7em & 1
R_x(θ)
Quantum CircuitStandard DecompositionsQueeze Decomposition@C=1em @R=.7em & 1 1
H R_z(θ) H @C=1em @R=.4em & 1R_zx(-θ2)
R_x(θ2) R_zx(-θ2)
Figure 1. sQueeze compilation pipeline in comparison to the native IBM
implementation. The circuit is decomposed into a sequence of basis gates and
then faster and higher fidelity pulses.

To join pulse-rescaling with better fidelity pulses we present sQueeze: a
suite of software tools that perform both asynchronous pulse calibration and
gate decompositions (see Fig. 1). We use 8 billion executions of the IBM
quantum devices to extensively test sQueeze across a range of use cases to
demonstrate the practicality of our work. Our contributions are as follows:

  * •

We demonstrate faster and more accurate parameterised $R_{x}(\theta)$ and
$R_{zx}(\theta)$ gates with direct pulse constructions, we build these pulses
using an asynchronous calibration server to track fluctuations in the backend
quantum devices.

  * •

We build a pass manager that decomposes a range of common quantum operations
using the new set of basis gates.

  * •

We perform extensive benchmarks of sQueeze compared to other state-of-the-art
methods using tomography, NISQ circuit benchmarks, and randomised
benchmarking.

  * •

sQueeze demonstrates up to a 4.1$\times$ speed-up for SU(2) gates, 3.1$\times$
speed-up for SU(4) gates and up to a 39.6% reduction in error for common
quantum algorithms.

##  Background

We start with a brief introduction to quantum computing, focusing on aspects
relevant to our work.

###  Quantum Computation

Quantum computation may be considered an extension of both probabilistic and
reversible computing. The qubit is a unit of quantum memory that stores any
unitary state described by $\ket{\psi}=\alpha\ket{0}+\beta\ket{1}$, where
$\alpha$, $\beta\in\mathbb{C}$ and $|\alpha|^{2}+|\beta|^{2}$ = 1. A more
general multi-qubit system is described as a probability distribution over the
convex set of these basis vectors;
$\ket{\psi}=\sum^{{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}2^{n}}}_{i}\alpha_{i}\ket{i}$
such that $\sum_{i}|\alpha_{i}|^{2}=1$. Quantum operations are rotations about
the vector-space spanned by an ensemble of qubits. They are unitary and hence
reversible operations that preserve the normalisation of the probability
distribution over quantum states. As such, an arbitrary quantum operation $U$
can be represented as a matrix acting on a quantum state $\ket{\psi}$ by
$U\ket{\psi_{0}}\rightarrow\ket{\psi_{1}}$.

###  Compiling Quantum Circuits to Pulses

Modern superconducting quantum systems are controlled via the capacitive
coupling of a charge qubit and a microwave resonator (Qiskit, ;
peterer2015coherence, ). The physical evolution of a quantum system is
described by a Hamiltonian operator $\mathscr{H}$. The relative evolution of
the system depending on the state of the microwave resonator can then be
considered a computational operation acting on that qubit. Computational
operations on a qubit may then be achieved by driving the microwave resonator
at a given amplitude for a given period of time. The action of this drive
channel is termed a ‘pulse’. As the pulse control is itself generated by a
classical computational system, the pulse control must be performed in
discrete units of time.

The pulse model includes a time dependent function that describes the ‘shape’
of the pulse based on $f$. The action on a quantum state $\psi_{t_{0}}$ from a
control pulse $f$ acting from time $t_{0}$ to $t_{1}$ with parameters
$\vec{\alpha}$ is then

(1)
$\ket{\psi_{t_{1}}}=e^{i\mathscr{H}\int_{t_{0}}^{t_{1}}f(t,\vec{\alpha})dt}\ket{\psi_{t_{0}}}\vspace{-2mm}$

Two common parametric pulses are the Derivative Removal by Adiabatic Gate
(DRAG) pulse for single-qubit operations (motzoi2009simple, ) and Gaussian-
Square (GS) pulse for operations that couple pairs of qubits
(sheldon2016procedure, ). Techniques such as process and Hamiltonian
tomography may be used to determine the set of control parameters that are
required to implement a particular gate (Granade_2017, ). This abstraction
from control pulses to computational operations allows a quantum program to
neatly encapsulate all lower level implementation details within a gate and
circuit model of computation. A sequence of computational gates is termed a
circuit. A circuit can be represented as a diagram, for example in Fig. 1,
where the lines represent qubits and the boxes represent operators acting on
specific qubits.

Quantum programs are specified at the gate level but to execute on a device
the circuit must be mapped to sequences of control pulses for each qubit. The
quantum compilation pipeline first decomposes operations into a sequence of
basis gates which are in turn decomposed into pulses and scheduled as seen in
Fig. 1. The basis gates are the small set of one- and two-qubit operations
that are implemented directly on the device as pulses. The basis gates are
furthermore dependent on the qubit and quantum device; not all pairs of qubits
support two-qubit operations. Typically the device coupling map is sparse,
which means swap operations must be inserted to ensure there are only
operations between connected qubits (sabre, ).

###  Tomography and Gate Calibration

While driving a microwave resonator causes a quantum system to evolve, it does
not provide any information as to what operation was applied to the quantum
state. A common technique for diagnosing an unknown quantum operation is
process tomography (merkel_tomography, ). Process tomography is performed by
preparing a set of quantum states in a spanning set of orthogonal bases,
applying the unknown operation to each of them, and then measuring each of the
outputs in a spanning set of orthogonal measurement bases
(greenbaum_tomography, ). By sweeping over a range of the drive parameters we
can construct a quantum operation as a function of the pulse parameters
(Granade_2017, ; quantum_process_tomography, ). These raw pulses will
typically perform a range of operations on the state. To construct a
particular computational basis gate the pulse parameters must be tuned to
remove unwanted components (howard, ). In situations where this is not
possible then a sequence of subsequent pulses may be constructed
(sheldon2016procedure, ). For well-understood physical systems the initial
stage of process tomography may be replaced with Hamiltonian tomography
(Granade_hamiltonian, ).

###  Gate Decomposition

Having constructed a set of computational basis gates we are still left with
an open problem: the set of all quantum operations is infinite but the basis
set is strictly finite. Luckily, it has been shown that all multi-qubit gates
can be decomposed to a set of universal single-qubit rotations and a single
entangling two-qubit gate (barenco1995elementary, ). As a result it is
sufficient to calibrate one two-qubit gate (such as a CNOT) and a set of
single-qubit gates to implement all rotations to an arbitrary accuracy.

A move towards parameterised gates is generally a more efficient approach for
gate decomposition than search methods like Solovay-Kitaev (dawson2005solovay,
). An arbitrary single-qubit operation may be described as a $U_{3}$ rotation
(nielsenchuang2011, ), which may in turn be decomposed into a sequence of
$U_{1}$ rotations about each basis. By parameterising one of these $U_{1}$
gates (either $R_{x}(\theta),R_{y}(\phi)$ or $R_{z}(\gamma)$) along with a
discrete set of operations that map between these bases, a single
parameterised gate may then construct the full set of $U_{3}$ operations with
constant overhead. The construction of larger arbitrary quantum operations can
then be performed by a Weyl decomposition (khaneja2000cartan, ;
zhang2004optimal, ).

In the case of Qiskit (Qiskit, ), the Hamiltonian of the system results in a
$U_{1}$ gate in the $Z$ basis that acts linearly as a function of time.
Parameterised $R_{z}(\gamma)$ gates may then be performed for free via
software (mckay2017efficient, ), resulting in the five gate $U_{3}$
decomposition:

(2)
$U_{3}(\theta,\phi,\lambda)=R_{z}(\phi+3\pi)\,\sqrt{X}\,R_{z}(\theta+\pi)\,\sqrt{X}\,R_{z}(\lambda).$

This requires two physical DRAG pulses instead of one because the $\sqrt{X}$
is not parameterised like the $R_{z}(\theta)$.

##  Pulse Control of Transmon Qubits

Now, we explore some existing pulse optimisation techniques that use models of
the pulse area to add parameterised gates to the basis set. These methods can
improve gate fidelity and schedule duration without requiring further
calibration.

###  Single-Qubit Pulse Scaling

The amplitude of Qiskit’s $X$ pulse can be scaled by $\frac{\theta}{\pi}$ to
achieve $R_{x}(\theta)$ rotations (gokhale2020optimized, ). Now single-qubit
gates can be implemented with only one direct $R_{x}(\theta)$ gate as follows,

(3)
$U_{3}(\theta,\phi,\lambda)=R_{z}(\phi+\pi)\,R_{x}(\theta)\,R_{z}(\lambda-\pi).$

This halves the schedule duration for an arbitrary $U_{3}$ gate from
$320\,\mathtt{dt}$ to $160\mathtt{dt}$, where $\mathtt{dt}$ is Qiskit’s
standard unit for duration and $\mathtt{dt}=0.22ns$ (gokhale2020optimized, ).
The $1.6\times$ improvement in fidelity is attributed to three sources
(gokhale2020optimized, ): shorter pulses, less calibration error
susceptibility, and smaller pulse amplitudes.

###  Two-Qubit Pulse Scaling

Qiskit only calibrates one two-qubit basis gate (Qiskit, ): a CNOT. This
results in longer decompositions than if a parameterised two-qubit gate was
part of the basis set (foxen2020demonstrating, ). Sometimes this CNOT is built
from echoed cross-resonance $CR\bigl{(}\pm\frac{\pi}{4}\bigr{)}$ pulses
(chow2011simple, ; sheldon2016procedure, ) with cancellation pulses on the
target qubit (sundaresan2020reducing, ) and single-qubit pulses as shown in
Fig. 2. The $CR\bigl{(}\pm\frac{\pi}{4}\bigr{)}$ are Gaussian-Square pulses
with a flat-top amplitude $A$, width $w$, and Gaussian flanks with standard
deviation $\sigma$. Their area is
$F=|A|[w+\sqrt{2\pi}\sigma\text{erf}(n_{\sigma})]$ (earnest2021pulse, ).

Figure 2. Qiskit CNOT pulse schedule where D0 and D1 are the drive channels,
and the control channel U0 couples the qubits. The cancellation pulses on D1
compensate for unwanted terms.

In this case, IBM’s calibrated cross-resonance pulses can be scaled to provide
direct $R_{zx}(\theta)$ without further device experiments. To implement
arbitrary $CR(\theta)$ rotations the Gaussian-Square pulses are scaled in
respect to 2$\theta F/\pi$, where $F$ is the original pulse area. Then
$R_{zx}(\theta)$ can be implemented as
$R_{zx}(\theta)=CR(\frac{\theta}{2})\,X\,CR(-\frac{\theta}{2})\,X$ where $X$
is applied to the control channel. Adding the new parameterised
$R_{zx}(\theta)$ gates to the basis set and using Cartan’s decomposition has
been shown to improve the fidelity by up to 38% and yield a 52% schedule time
reduction for arbitrary SU(4) decompositions (earnest2021pulse, ;
gokhale2020optimized, ).

##  sQueeze

From the previous methods we have two main challenges: extending the set of
parameterised basis gates to enable speed-ups, and ensuring the accuracy of
computation does not suffer.

To achieve these goals we propose sQueeze; a combined calibration server and
pulse compilation pass. The calibration server provides live calibrations for
direct $R_{x}(\theta)$ and $R_{zx}(\theta)$ pulses. The compilation pass then
decomposes logical quantum operations in terms of this extended set of pulses
that use the scaling parameters provided by the calibration server. This two
stage asynchronous approach ensures that the user is able to compile their
circuit with the most up-to-date pulse parameters without being blocked by
device calibrations.

###  sQueeze $R_{x}(\theta)$ Pulses

We extend the existing DRAG pulse scaling to reshape the duration in addition
to the amplitude and implement $R_{x}(\theta)$ rotations faster than
$160\,\mathtt{dt}$ (gokhale2020optimized, ). sQueeze begins by performing a
sweep over $\text{DRAG}(A,t,\sigma,\beta)$ pulses with parameters
$64\,\mathtt{dt}\leq t\leq 160\,\mathtt{dt}$, $0\leq A\leq 1$ in order to find
the fastest $R_{x}(\pi)$ operation. Note, $\sigma,\beta$ are the same as
Qiskit’s $X$ pulse parameters. This fastest $X$ gate is then parameterised by
$A=A_{0}$ and $t=t_{0}$. After finding this fastest $X$ operation, calibration
circuits are run over the range $0\leq A\leq A_{0}$ and the data is fit to an
ideal $\text{sin}^{2}\bigl{(}\frac{\theta}{2}\bigr{)}$ function using the
Levenberg-Marquardt curve-fitting algorithm (levenberg1944method, ). To
calculate the amplitude required to implement any $R_{x}(\theta)$ gate, we
equate the fitted $A_{1}\,\text{sin}^{2}(\omega A+\phi)+\delta$ function to
the ideal probability distribution function to give,

(4) $A_{1}\,\text{sin}^{2}(\omega
A+\phi)+\delta=\text{sin}^{2}\Bigl{(}\frac{\theta}{2}\Bigr{)}$ (5)
$A=\frac{\text{sin}^{-1}\Biggl{(}\sqrt{\frac{\text{sin}^{2}\Bigl{(}\frac{\theta}{2}\Bigr{)}-\delta}{A_{1}}}\Biggr{)}-\phi}{\omega}$

$A$ is then the applied amplitude of the DRAG pulse for $R_{x}(\theta)$. As
the single-qubit pulses are stable over the course of days to weeks, seen in
Fig 3, we run the calibration procedure on average once every two hours and
use trailing averages to determine the $\sin^{2}$ parameters.

Figure 3. Amplitude of Qiskit’s $X$ pulse over four months for IBM Lima. There
is a data gap between days 20 and 37.

While the pulses are stable over the medium to long term, IBM devices
experience significant short term fluctuations. Fig. 4 shows the proportion of
$\ket{1}$ states measured over four months and 260 million shots. The light
blue shaded region highlights the full range of results that show points with
error up to 40%. However, the darker region represents one standard deviation
and shows that the experimental data matches the ideal
$\sin^{2}\bigl{(}\frac{\theta}{2}\bigr{)}$ curve on average. Hence, we use the
mean of the periodic calibration data over a two day window to reduce the
influence of short term noise on the system.

Figure 4. IBM Nairobi Qubit 6 testing $\text{DRAG}(A,d,\sigma,\beta)$ pulses
for $0\leq A\leq 1$ over $2.6\times 10^{6}$ shots and 4 months.

###  sQueeze $R_{zx}(\theta)$ Pulses

sQueeze extends the Earnest CR scaling method to find faster CNOT gates. After
the initial Earnest scaling, we use a local amplitude sweep to fine tune the
resulting CR pulse accuracy. Limited by computational power and device queues,
we use particle filtering to search for the scaling factors. Then we use the
original Earnest method to implement faster $R_{zx}(\theta)$ gates.

####  CR Pulse Reshaping

We find that performing a naïve rescaling of Qiskit’s initial pulse envelope
$GS(A,w,d,\sigma)$ to halve the duration of the CR pulse (earnest2021pulse, )
increases the average CNOT error rate from $2.33\%$ to $6.18\%$. This test was
performed using $26.4$ million shots over all qubits on IBM Quito, Manilla,
Belem and Lima. Due to this increased error rate we supplement the initial
pulse-rescaling with a local parameter search and reshape the pulses again in
order to improve the accuracy of the scaled CR pulse. When reshaping these
pulses we are constrained by the discrete intervals of $16\,\mathtt{dt}$ over
which pulses are defined, while the normalised amplitude $A$ is a continuous
complex number such that $0<|A|\leq 1$.

Figure 5. IBM Nairobi CNOT (0, 1) accuracy for the $Z$ basis as the scaling
factor $c$ varies over 1.6 million shots.

sQueeze begins rescaling the pulse by increasing the amplitude and decreasing
the pulse duration by a scalar factor $c$. Our initially reshaped pulse is
described by a rescaled amplitude $A^{\prime}=cA$ width
$w^{\prime}=\frac{F-\sigma\norm{A^{\prime}}\sqrt{2\pi}}{A^{\prime}}$, a
rescaled duration $d^{\prime}=16\left\lfloor\frac{w^{\prime}+\sigma
n_{\sigma}}{16}\right\rfloor$ where $n_{\sigma}=\frac{d_{0}-w_{0}}{\sigma}$
and $F$ is the area of the original pulse envelope. To improve the accuracy of
this reshaped pulse we sweep over nearby amplitudes using a fine tuning factor
$k$. The new CR pulse is built using Gaussian-Square pulses
$GS(kA^{\prime},w^{\prime},d^{\prime},\sigma)$. The need for this $k$-fine-
tuning can be seen in Fig. 5, where $c$-scaled CR pulses were used to
construct CNOT operations and the average accuracy of each computational basis
state varies as the scalar factor $c$ changes. The results of the $c$-scaling
and the $k$-fine-tuning sweep for CR pulses on two different devices can be
seen in Fig 6. For each choice of $c$ there is a choice of $k$ that improves
the accuracy of the constructed gate.

(a) IBM Lima (1, 3)

(b) IBM Belem (3, 4)

Figure 6. Example CNOT accuracy averaged over the four basis states and 3.1
million shots per qubit pair as $k$ and $c$ vary. The heatmap is unique for
each device and qubit pair.

####  Pulse Parameter Particle Filtering

A full grid search is informative but extremely resource intensive. Testing
$n_{c}=24$ and $n_{k}=8$ scalar factors in the four basis states as shown in
Fig. 6, requires 8 batch requests per qubit pair. This takes on average 24
hours, given IBM’s public queue times.

Instead of executing a full grid search, we build off the historical grid data
and perform particle filtering: an alternative search method that does not
require a differentiable or continuous function (djuric2003particle, ). We
begin particle filtering by defining a region in the $c-k$-domain that has
historically produced relatively good results for that particular qubit pair.
For an initial pass we regularly space a grid of particles
$p_{0,i}=(c_{0,i},k_{0,i})$ over this region, along with a particle at $c=1$,
$k=1$ to implement the default Qiskit strategy as a baseline. For each
particle we construct a CNOT operation and apply it against four computational
states $\ket{00},\ket{01},\ket{10},$ and $\ket{11}$. The resulting accuracy of
the particle then defines an associated weight $\alpha_{0,i}$. The
distribution of particle weights now approximates the accuracy function over
the $c-k$ domain. As these distributions are relatively flat we increase the
gradient by raising each score to the power of $32$ before the weights are
normalised.

To narrow our domain we distribute a new selection of particles based on the
function approximated by the particle weights of the previous round. This
encourages the clustering of points around known good selections of pulses.
New particles $\vec{p}_{n}$ are drawn from the previous round’s particles such
that $p_{n-1,i}$ is selected with probability $\alpha_{n-1,i}$. Each of these
re-sampled particles is perturbed by a small amount of Gaussian noise. The
standard deviation of this noise is set to half the size of the initial
particle spacing. At this point we add two special particles; the best
particle from the previous round and Qiskit’s particle. The most accurate
particle from the previous round is the one with the highest weight, if there
is a tie then we choose the particle with the largest $c_{i}$ as we prefer
faster pulses. This set $\vec{p}_{n}$ now represents the next round of input
for the particle filtering method. An illustrative example is shown in Fig. 7.
By the fourth iteration seen in Fig. 7(d), the points form two clusters that
match the most accurate regions of the original grid shown in Fig. 6(a).

(a) Iteration 1

(b) Iteration 2

(c) Iteration 3

(d) Iteration 4

Figure 7. Example of particle filtering for IBM Lima Qubits (1, 3). Point size
is proportional to $a^{p}$, $a$ is accuracy and $p=32$.

Furthermore, we only test particles with $c_{i}\geq 1$ to ensure both a faster
and more accurate pulse. As Qiskit’s CR parameters are included in each round,
sQueeze will always perform at least as well as Qiskit. If the best non-Qiskit
particle is worse than Qiskit then the process resets the particles to the
initial grid. This reset occurs on average once every 43 rounds of particle
filtering. This process is performed asynchronously by the calibration server,
which reports the current best selection of particles. A new round of particle
filtering is performed on average once every two hours. These scaled cross-
resonance pulses can now be used to define improved $R_{zx}(\theta)$ pulses
using the Earnest method outlined in Sec. 2.

###  Optimising Decompositions

The above strategies proposed extend the set of basis gates with direct pulse
implementations but this does not immediately translate into more efficient
decompositions for more complex gates. We must also provide decompositions in
terms of our newly parameterised $R_{x}(\theta)$ and $R_{zx}(\theta)$.

####  Single-Qubit Gate Decompositions

As $R_{z}$ operations are ‘free’ operations that are considered to be
perfectly accurate on IBM devices (mckay2017efficient, ), all single-qubit
rotations are benchmarked in terms of the duration of $R_{x}$ gates. We have
previously demonstrated a direct $R_{x}(\theta)$ gate for
$0\leq\theta\leq\pi$, but with the addition of two free $R_{z}$ operations we
implement negative rotations with the same schedule time and accuracy as our
direct $R_{x}(\theta)$ by

(6) $R_{x}(-\theta)=R_{z}(\pi)\,R_{x}(\theta)\,R_{z}(\pi).$

Equipped with a parameterised $R_{x}(\theta)$, free $R_{z}$ operations and Eq.
3 we find a decomposition of a $U_{3}$ gate by

(7)
$U_{3}(\theta,\phi,\lambda)=R_{z}\Bigl{(}\phi+\bigl{(}\frac{\pi}{2}\bigr{)}\Bigr{)}\,R_{x}(\theta)\,R_{z}\Bigl{(}\lambda-\bigl{(}\frac{\pi}{2}\bigr{)}\Bigr{)}.$

The total pulse schedule length and accuracy now only depend on a single fast
$R_{x}$ pulse instead of two standard $\sqrt{X}$ pulses, as illustrated in
Fig. 8.

Figure 8. Standard compilation $U_{3}$ pulse schedule (a) vs sQueeze (b).
sQueeze takes $78.12\,\mathtt{dt}$ on average, more than four times faster
than Qiskit’s $320\,\mathtt{dt}$ schedule where $1\mathtt{dt}=0.22ns$.

####  Multi-Qubit Gates

For larger gates we use the Weyl chamber decomposition (zhang2003geometric, ;
zhang2004optimal, ) with $R_{zx}$ as a basis gate. $R_{xx}$, $R_{yy}$ and
$R_{zz}$ can all be implemented using a single $R_{zx}$ pulse, halving the
number of two-qubit operations, compared to decompositions using CNOTs. An
example of the Qiskit’s $R_{xx}$ decomposition compared to the Weyl
decomposition is shown in Fig. 9. Two-qubit gates can now be implemented up to
50% faster (earnest2021pulse, ). In particular, $C(\sqrt{X})$, an important
gate for the Toffoli decompositions below, can now be decomposed into a single
$R_{x}(\frac{\theta}{2})$, $R_{zx}(-\frac{\theta}{2})$, and a free
$R_{z}(\frac{\pi}{4})$.

@C=1em @R=.9em & H 1 1 H
H R_z(θ) H

(a) Qiskit

@C=1em @R=1.2em & H 1R_zx(θ) H
R_zx(θ)

(b) sQueeze

Figure 9. Comparison of Qiskit’s $R_{xx}(\theta)$ decomposition into multiple
CNOT gates compared to sQueeze’s Weyl decomposition using a direct
$R_{zx}(\theta)$ as a basis gate. Each Qiskit CNOT is further decomposed into
more pulses as seen in Fig. 2.

####  Toffoli Decomposition

We additionally consider one common three Qubit gate: the Toffoli
(nielsenchuang2011, ). As shown in Fig. 10(a), Qiskit’s implementation of the
Toffoli gate requires six two-qubit gates and single-qubit rotations
(equivalenceLibrarySourceCode, ). By constructing a $C(\sqrt{X})$ gate from
the direct $R_{zx}(\theta)$ basis gate the Weyl decomposition gives an
implementation of a Toffoli gate that only requires five two-qubit gates, and
no additional physical single-qubit gates as shown in Fig. 10(b).

@C=.8em @R=0.5em @!R & 2 2 1 T 1
1 1 T T^†
H T^† T T^† T H

(a) Default Qiskit decomposition using only single-qubit gates and CNOTs.

@C=.8em @R=0.5em @!R & 1 1 2
1 S^† 1
X Z X Z X 17381em–

(b) sQueeze decomposition using $C(\sqrt{X})$, the last two gates commute.

Figure 10. Two equivalent Toffoli decompositions with different basis gates.
(a) Qiskit native. (b) sQueeze decomposition, the final two gates commute
admitting two different implementations of the Toffoli gate, which may be used
to minimise routing.

The Toffoli gate poses an additional problem; while the circuit presents
operations between all pairs of qubits, this is often not physically
realisable on NISQ device topologies (sabre, ). To resolve this dilemma qubits
must be swapped to remove non-physical operations, with each swap requiring
three CNOTs. The number of these swap operations depends on the allocation of
the computational qubits to physical qubits on the device. As a result the
total schedule duration for Toffoli gates ranges from $8,544\,\mathtt{dt}$ to
$56,192\,\mathtt{dt}$ with a mean of $22,588\,\mathtt{dt}$ depending on the
qubits and device topology. As the final two gates of the sQueeze Toffoli
implementation commute, it is possible to select which Toffoli will minimise
the number of swap operations, further reducing the number of two-qubit gates.

###  Pass Manager

Armed with the parameterised pulses in Sec. 4.1 and 4.2 and their associated
gate decompositions in Sec. 4.3, sQueeze combines these transformations into a
single transpilation function shown in Algorithm 1. First, the circuit is
unrolled into the basis gates [$R_{x},R_{z},R_{zx},\text{CNOT}$] using
Qiskit’s existing equivalence library and the new equivalences derived in Sec.
4.3. Then other passes like routing, layout, and optimisation are applied by
using Qiskit’s existing `transpile` function. Finally, custom calibration is
added to the $R_{x}(\theta)$ and $R_{zx}(\theta)$ gates based on the work in
Sec. 4.1 and 4.2 respectively.

Algorithm 1 sQueeze Compilation Pipeline

1:_pulse-library_ $\leftarrow$ Pulse parameters from query server

2:for  _multi-qubit gate_ in _circuit_ do

3: Unroll and Decompose gate with Weyl decomposition

4:end for

5:_sel_ $\leftarrow$ Qiskit’s equivalence library
(equivalenceLibrarySourceCode, )

6:_sel_[$U_{3}$] $\leftarrow$ Equation 7.

7:_basis-gates_ $\leftarrow$ [$R_{x},R_{z},R_{zx},\text{CNOT}$]

8:for  _gate_ in _circuit_ do

9: if  _gate_ not in _basis-gates_ then

10: Replace _gate_ with circuit equivalence from _sel_.

11: end if

12:end for

13:Run Qiskit’s `transpile` function for other transpilation passes

14:for  _gate_ in _circuit_ do

15: if  _gate_ = $R_{x}(\theta)$ or _gate_ = $R_{zx}(\theta)$ then

16: Replace _gate_ with parameterised pulse from _pulse-library_

17: end if

18:end for

###  Calibration Server

User CircuitUpdateResults DatabaseQueryPass ManagerScheduleDevice QueueDevice
ExecutionQueueExecutionQuantum DevicesUser ResultsQuery ServerCalibration
ResultsResults DatabaseCalibration CircuitsSelectionCalibration Server Figure
11. Custom compiler flow to convert a high-level quantum circuit to an
optimised pulse schedule, which is executed on a quantum device. The pass
manager requests the latest pulse parameters from the query server to build
custom $R_{x}(\theta)$ and $R_{zx}(\theta)$ gates. The calibration server
collects real device data, processes measurement results, and updates the
query server with the best parameters.

In order to transpile gates down to the pulses described in Sec. 4.1 and Sec.
4.2, we must first characterise these pulses. Rather than block compilation on
the completion of these characterisations, we perform these experiments
asynchronously on a dedicated ‘calibration server’ and herald the results to a
centralised ‘query server’. The pass manager introduced in Sec. 4.4 may then
obtain the most recent pulse parameters from the query server for use in
transpiling quantum circuits. Fig. 11 shows how a high-level quantum circuit
is converted to an optimised pulse schedule that can be executed on a NISQ
device using our pass manager.

The scheme consists of two parts: a calibration server, and a query server.
The calibration server sends experiments to the NISQ backend, processes the
measurement results, and selects the best parameters to update the query
server. The query server is a fast, lightweight endpoint that stores and
returns the selected pulse parameters for $R_{x}(\theta)$ and
$R_{zx}(\theta)$. Each time a circuit is compiled, the sQueeze pass manager
requests the current parameters to build optimised pulse schedules.

The single-qubit pulse calibrations are performed as illustrated in Fig. 12.
The calibration server will then clean the data by removing any outliers more
than 1.5 standard deviations from the mean and calculate the trailing average
using the last two days worth of data. The resulting pulse is validated
against Qiskit’s $R_{x}(\theta)$ pulse and is only posted to the query server
if it reports a higher mean accuracy.

DRAG($\alpha$ $d$, $\sigma$, $\beta$) circuits for $0\leq\alpha\leq 1$Data
CollectionResults DatabaseClean, fit and validate $\sin^{2}$
curveSelectorValidationDeviceDevDeviceQuantum DevicesQuery Server _Repeat_
Figure 12. $R_{x}(\theta)$ calibration for qubit $q_{i}$ uses two concurrent
processes that share a database. One collects data as outlined in Sec. 4.1 and
the second fits and validates a $\sin^{2}$ curve.

To provide real time $R_{zx}\bigl{(}\frac{\pi}{2}\bigr{)}$ pulse parameters
the calibration server implements particle filtering as presented in Sec. 4.2,
cycling through the calibrations for each pair of connected qubits. As the IBM
job queue is restricted to 100 circuits per submission, each iteration can
only test 23 particles along with the previous best round and Qiskit. As
Qiskit is included as one of the submissions in the particle filtering method,
the resulting pulse parameters are at least as performant as Qiskit. The
Qiskit particle is reported as the best particle out of the $25$ approximately
$2.3\%$ of the time.

##  Benchmarks

We benchmark sQueeze against the Gokhale (gokhale2020optimized, ), Earnest
(earnest2021pulse, ) and native Qiskit (Qiskit, ) pulse decompositions over
IBM’s 5 and 7 qubit devices: Belem, Lima, Manila, Quito, and Nairobi. Our
primary metrics are the error rate and total execution time reported in units
of $\mathtt{dt}$.

Individual Gate Benchmarks: We show the pulses generated by sQueeze correctly
implement the intended operations by performing tomography
(greenbaum_tomography, ; merkel_tomography, ) in the $X,Y,$ and $Z$ bases and
benchmark the performance against other methods. We test our new
$R_{x}(\theta)$, and $R_{zx}(\theta)$ for $\theta$ from 0 to $\pi$, and the
CNOT and Toffoli gates built with these basis gates. Each gate is tested in
the $2^{n}$ possible states for each basis and all possible qubit allocations
(howard, ; Granade_2017, ).

Common Quantum Algorithm Benchmarks: sQueeze is tested against four well-known
quantum algorithm benchmarks; the quantum Fourier transform (QFT)
(weinstein2001implementation, ), Quantum Approximate Optimization Algorithm
(QAOA) (farhi2014quantum, ), the hidden bitstring variant of the
Bernstein–Vazirani algorithm (BV) (bernstein1997quantum, ), and the CDKM
Ripple Carry Adder (cuccaro2004new, ). These algorithmic benchmarks represent
a range of expected workloads and by association commonly used quantum gates.

Randomised Benchmarking (RB): We additionally perform randomised benchmarking
(RB) trials to compare the average gate fidelity (knill2008randomized, ). RB
constructs circuits of depth $k$ randomised quantum operations before applying
the inverse of each gate in reverse order for a total action of $I$ on all
qubits. In a system without noise, the set of $n$ qubits should return to the
initial state $\ket{0}^{\otimes n}$ with $100\%$ probability. As $k$ varies,
the average gate fidelity can be calculated by fitting to

(8) $P(\ket{0}^{\otimes n})=\text{SPAM}_{\alpha}p^{k}+\text{SPAM}_{\beta}$

where the SPAM terms absorb the state preparation and measurement errors,
$\epsilon_{\text{per gate}}=1-p-\frac{1-p}{2^{n}}$ is the average error rate
per gate, and $n$ is the number of qubits in the circuit. We performed two
randomised benchmarking trials: the first with the basis set SU(2) to test the
DRAG pulse scaling and then on the expanded set SU(4) to test cross-resonance
pulse scaling.

##  Evaluation

Benchmark | Mean Benchmark Error (%) | Improvement vs. Qiskit
---|---|---
sQueeze | Earnest | Gokhale | Qiskit | sQueeze | Earnest | Gokhale
$R_{x}(\theta)$ |  $0.69\pm 0.00$.13) |  N/A† |  $1.24\pm 0.00$.50) |  $1.52\pm 0.00$.60 ) |  $52.70$ % |  N/A† |  $11.73$ %
CNOT |  $2.87\pm 0.00$.95) |  N/A† |  N/A† |  $2.88\pm 0.00$.93) |  $0.52$ % |  N/A† |  N/A†
$R_{zx}(\theta)$ |  $2.14\pm 0.00$.52) |  $2.15\pm 0.00$.47) |  N/A† |  $2.76\pm 0.00$.83) |  $22.63$ % |  $22.09$ % |  N/A†
Toffoli |  $3.92\pm 0.00$.31) |  N/A† |  N/A† |  $4.65\pm 0.00$.18) |  $15.80$ % |  N/A† |  N/A†
RB SU(2) |  $12.40\pm 0.00$.25) |  N/A† |  $12.39\pm 0.00$.24) |  $12.45\pm 0.00$.24) |  $0.40$ % |  N/A† |  $0.48$ %
RB SU(4) |  $4.42\pm 0.00$.45) |  $4.64\pm 0.00$.50) |  $6.14\pm 0.00$.76) |  $5.83\pm 0.00$.63) |  $24.25$ % |  $20.41$ % |  $-5.30$ %
QAOA |  $40.53\pm 0.14$.61) |  $48.22\pm 0.21$.29) |  $52.08\pm 0.22$.69) |  $52.82\pm 0.16$.09) |  $23.27$ % |  $8.70$ % |  $1.16$ %
BV |  $67.41\pm 0.02$.89) |  $67.49\pm 0.03$.03) |  $69.01\pm 0.03$.66) |  $68.94\pm 0.03$.78) |  $2.22$ % |  $2.10$ % |  $-0.11$ %
QFT |  $25.81\pm 0.09$.52) |  $26.09\pm 0.09$.86) |  $26.00\pm 0.09$.78) |  $25.68\pm 0.10$.05) |  $-0.51$ % |  $-1.60$ % |  $-1.26$ %
CDKM Adder |  $29.26\pm 0.15$.99) |  $29.64\pm 0.16$.18) |  $29.31\pm 0.16$.31) |  $29.25\pm 0.16$.39) |  $0.04$ % |  $-1.31$ % |  $-0.18$ %
Table 1. Average fidelity performance across all benchmarks. The error is the distance from the ideal probability distribution, except for RB where it is the fitted error per gate. ${\dagger}$ indicates this method is equivalent to Qiskit. Gate |  Gate Schedule Duration ($\mathtt{dt}$) | Improvement vs. Qiskit
---|---|---
sQueeze | Earnest | Gokhale | Qiskit | sQueeze | Earnest | Gokhale
$X$ / $\sqrt{X}$ |  $77.6\pm 1.1$.5) |  N/A† |  N/A† |  $160\pm 0.$.0) | 2.06 $\times$ |  N/A† |  N/A†
$R_{x}$ / $U_{3}$ |  $77.6\pm 1.1$.5) |  N/A† |  $160\pm 0.$.0) |  $320\pm 0.$.0) | 4.12 $\times$ |  N/A† |  2.00 $\times$
$CR(\pi/4)$ |  $508\pm 154.$.7) |  N/A† |  N/A† |  $564\pm 178.$.2) | 1.11 $\times$ |  N/A† |  N/A†
$R_{zx}(\theta)$ |  $1364.6\pm 29.9$.8) |  $1472.7\pm 34.7$.5) |  N/A† |  $3217.8\pm 71.2$.9) | 2.36 $\times$ |  2.19 $\times$ |  N/A†
Toffoli |  $18\,786.5\pm 275.8$.5) |  N/A† |  N/A† |  $22\,277.9\pm 396.1$.1) | 1.18 $\times$ |  N/A† |  N/A†
Table 2. Average gate schedule duration in units of $1\mathtt{dt}=0.22ns$.
${\dagger}$ indicates this method is equivalent to Qiskit.

Here we present a range of empirical benchmarks for sQueeze with a focus on
individual gate accuracies, common benchmark quantum circuits and random
circuits run over two weeks. Tests are run as frequently as queue times permit
(in the best case, every few minutes) throughout Qiskit’s calibration period
without respect to the state of sQueeze’s calibration server. The sQueeze
calibration runs on average every four hours and at most every two hours. This
ensures that tests are not performed immediately following a pulse calibration
or only at the end of Qiskit’s calibration period. The fidelities for each
benchmark are summarised in Table 1 and the gate durations are compared in
Table 2. For each benchmark presented within a table we bold the best
performing method. The shaded regions in the figures represent a 95%
confidence interval.

###  Basis Gate Comparisons

To demonstrate the improvements in the performance and accuracy of sQueeze we
provide tomographic benchmarks and pulse durations for the $R_{x}(\theta)$,
CNOT, and $R_{zx}(\theta)$ compared to the Earnest, Gokhale, and Qiskit
methods. We additionally evaluate the Toffoli decomposition into these basis
gates.

####  $R_{x}(\theta)$ and Single-Qubit Gates

To evaluate the accuracy of sQueeze’s parameterised $R_{x}(\theta)$ we perform
process tomography for range of $0\leq\theta\leq\pi$. A representative sample
for IBM Quito Qubit 0 over 2.35 million shots is illustrated in in Fig 13. The
error for each basis in this trial were 0.3% (X), 0.8% (Y), 0.9% (Z). This is
repeated for all qubits on all benchmarks devices and confirms the error is
similar in all bases.

(a) X Basis

(b) Y Basis

(c) Z Basis

Figure 13. $R_{x}(\theta)$ tomography on IBM Quito Qubit 0 over 2.35 million
shots and 98 angles in the $X,Y,$ and $Z$ bases.

To compare against other state-of-the-art methods we perform logical
$R_{x}(\theta)$ gates over the range $0\leq\theta\leq\pi$ and use each
method’s respective pulse decomposition. We execute these pulse schedules for
the $Z$ basis states and measure the 1-norm distance between the ideal
distribution and the measurements results. The average error over all
benchmark devices excluding Belem can be seen in Fig. 14. We tested each qubit
on the benchmark devices continuously for a total of 592 million shots. For
single-qubit pulses, we note that the Earnest method is equivalent to Qiskit.
sQueeze demonstrates a mean gate error of 0.69% compared to Gokhale’s mean
error of 1.24% and Qiskit’s mean error of 1.52%. sQueeze shows an average
$44.3\%$ reduction in the error rate of individual $R_{x}(\theta)$ gates
compared to the next best method. Expanded results for each device can be
found in Table 3, where sQueeze shows up to a 67.1% improvement compared to
the next best method.

Figure 14. $R_{x}(\theta)$ error for all qubits on the benchmark devices excluding IBM Belem over and 592 million shots. Device |  Mean $R_{x}(\theta)$ Error (%) | Improvement vs. Qiskit
---|---|---
sQueeze | Gokhale | Qiskit | sQueeze | Gokhale
Lima |  0.6 $\pm$ 0.1 |  1.8 $\pm$ 0.5 |  1.8 $\pm$ 0.9 |  67.1 % | -0.3 %
Manila |  0.8 $\pm$ 0.7 |  1.0 $\pm$ 0.8 |  1.0 $\pm$ 0.8 |  24.4 % | 2.8 %
Nairobi |  0.7 $\pm$ 0.3 |  0.7 $\pm$ 0.3 |  1.2 $\pm$ 0.6 |  46.0 % | 42.0 %
Quito |  0.9 $\pm$ 0.4 |  1.9 $\pm$ 0.6 |  2.1 $\pm$ 1.0 |  57.9 % | 8.8 %
Average |  0.7 $\pm$ 0.1 |  1.3 $\pm$ 0.6 |  1.5 $\pm$ 0.5 |  52.7 % | 11.7 %
Table 3. The mean $R_{x}(\theta)$ error per qubit for 98 angles between 0 and
$\pi$ over 14 days and 592 million shots.

Narrowing our focus we examine the performance of a single device that has
been excluded from the average in Fig. 14. The performance of IBM Belem
between July and October 2022 is shown in Fig. 15. This is averaged over all
qubits on the device and 309 million experimental shots. Belem was performing
similarly to other devices from July to August, but by September the $(3,4)$
CNOT had a $100\%$ error rate (IBM subsequently removed the connection) and
the maximum error $R_{x}(\theta)$ error jumped from $2.0$ to $12.8\%$. The
Gokhale method uses Qiskit’s calibration, exacerbating the inaccuracy as the
maximum error increases from $2.2\%$ to $17.2\%.$ In comparison, the mean
sQueeze error only increased from $0.9\%$ to $1.4\%$, resulting in a mean
reduction in error of $88.4\%$ compared to Qiskit and $90.2\%$ relative to
Gokhale. This demonstrates that sQueeze can tolerate fluctuation in the
calibration of the pulses compared to methods that solely rely on pre-
calibrated data. Nonetheless, we have excluded Belem from all subsequent tests
for a fair comparison.

(a) July - August

(b) September - October

Figure 15. A comparison of $R_{x}(\theta)$ error rates from July to October on
the IBM Belem device. Until August the max. average error was 0.9% (sQueeze),
2.2% (Gokhale), and 2.0% (Qiskit) over 109 million shots. By September this
jumped to 17.2% (Gokhale), 12.8% (Qiskit), while sQueeze remained at 1.42%
over 220 million shots.

Having established the improvement in the accuracy of sQueeze for the
$R_{x}(\theta)$ gate, we next consider the improvement in the corresponding
pulse schedule durations. The average schedule durations for 1-qubit gates in
Table 2 are calculated by using the average $R_{x}(\theta)$ pulse duration for
each qubit listed in Appendix A.1. sQueeze achieves an average 2.06$\times$
speed-up for the $R_{x}(\pi)$ and $R_{x}(\frac{\pi}{2})$ gates that Qiskit
directly calibrates.

For more general $R_{x}$ and $U_{3}$ gates, sQueeze can implement these gates
with a single direct $R_{x}(\theta)$ instead of two $\sqrt{X}$ gates as in
Qiskit’s implementation. As a result, sQueeze’s mean speed-up doubles to
4.12$\times$ compared to Qiskit. The sQueeze decomposition requires the same
number of pulses for a $U_{3}$ gate as the Gokhale method but with the
underlying reduction in the pulse duration sQueeze still exhibits a
2.06$\times$ speed-up.

####  $R_{zx}(\theta)$ and Two-Qubit Benchmarks

In addition to single-qubit gates, sQueeze also scales the cross-resonance
pulses for qubits pairs on IBM devices. These entangling pulses are the basis
of all CNOT gates on the benchmark devices. To test the fidelity of the
sQueeze CNOT, we use the 1-norm distance between the observed measurement
results and the ideal distribution as a metric for the gate error. As the
Earnest and Gokhale CNOT implementations are equivalent to Qiskit, we compare
the sQueeze CNOT to the Qiskit CNOT over the range of computational basis
states shown in Fig. 16. The measurement results are averaged over 245 million
shots and all qubits pairs on the benchmark devices except Belem as discussed
above. In Fig. 16, it is evident that the sQueeze and Qiskit error for each
state is approximately equivalent. The average sQueeze CNOT error is 2.87
$\pm$ 0.95%, which is commensurate with Qiskit’s error of 2.88 $\pm$ 0.93%.
This demonstrates that sQueeze achieves an equivalent CNOT fidelity to Qiskit
while utilising faster cross-resonance pulses.

Figure 16. sQueeze CNOT error averaged over all connected qubit pairs on the
benchmark devices and 245 million shots.

To determine the speed-up of the sQueeze CNOT, we take the average of pulse
scaling factor $c$ from the particle filter server database and build the
corresponding scaled $R_{zx}\bigl{(}\pm\frac{\pi}{4}\bigr{)}$ for every pair
of connected qubits on the benchmark devices. The sQueeze cross-resonance
pulses are up to 1.61$\times$ faster than Qiskit’s and 1.11$\times$ faster on
average. The calibration server ensures the pulses are never slower than
Qiskit. Hence, sQueeze provides faster and equal fidelity CNOTs.

(a) X Basis

(b) Y Basis

(c) Z Basis

Figure 17. $R_{zx}(\theta)$ tomography on IBM Nairobi qubits (0,1) over 1.58
million shots. Mean error 1.00%($X$), 0.53%($Y$), 1.03%($Z$).

To create parameterised $R_{zx}(\theta)$ gates, sQueeze uses the Earnest
method in combination with the calibration server pulse parameters to generate
faster Gaussian-Square pulses. To confirm the fidelity of the new
$R_{zx}(\theta)$ gates, we perform tomography over the range
$0\leq\theta\leq\pi$. This was repeated for all qubits on all benchmark
devices to confirm that all bases had similar error. An example for IBM
Nairobi Qubits (0,1) is shown in Fig. 17 over 1.58 million shots. The mean
error in each basis was $1.00\%$ (X), $0.53\%$ (Y), and $1.03\%$ (Z).

To benchmark the sQueeze $R_{zx}(\theta)$ gates against Earnest and Qiskit we
compare average performance in the $Z$ basis states. The 1-norm distances of
the measurement results to the action of the ideal operation over the range
$0\leq\theta\leq\pi$ are shown in Fig. 18. This was averaged over all qubits
on all the benchmark devices excluding IBM Belem. The sQueeze pulses have an
average error of 2.1%, compared to 2.2% for Gokhale and 2.8% for Qiskit over
608 million shots. This demonstrates sQueeze can reduce error by an average of
$22.6\%$ and up to $49.0\%$ for IBM Nairobi relative to Qiskit. For an
expanded set of results per device see Table 4.

Figure 18. $R_{zx}(\theta)$ error for all connected qubit pairs on all benchmark devices excluding Belem over 14 days and 608 million shots. Device |  Mean $R_{zx}(\theta)$ Error (%) | Improvement vs. Qiskit
---|---|---
sQueeze | Earnest | Qiskit | sQueeze | Earnest
Lima |  1.8 $\pm$ 0.3 |  1.8 $\pm$ 0.1 |  2.1 $\pm$ 1.0 |  13.7 % | 12.8 %
Manila |  1.9 $\pm$ 1.3 |  2.0 $\pm$ 1.4 |  2.2 $\pm$ 1.3 |  16.2 % | 10.9 %
Nairobi |  2.0 $\pm$ 1.1 |  2.0 $\pm$ 1.0 |  3.9 $\pm$ 1.8 | 49.0 % |  49.1 %
Quito |  2.9 $\pm$ 1.1 |  2.8 $\pm$ 1.1 |  2.9 $\pm$ 2.1 | 0.1 % |  0.8 %
Average |  2.1 $\pm$ 0.5 |  2.2 $\pm$ 0.5 |  2.8 $\pm$ 0.8 |  22.6 % | 22.1 %
Table 4. The average $R_{zx}(\theta)$ averaged over all connected qubits on
the device.

Having established the equivalent fidelity of the sQueeze $R_{zx}$ gate to
previous methods, we now demonstrate its reduced pulse duration. The schedule
lengths averaged over 100 $R_{zx}(\theta)$ gates for $0\leq\theta\leq\pi$ and
all connected qubits on the benchmark devices are listed in Table 5. The
Earnest method of scaling results in a 2.14-2.21$\times$ speed-up relative to
Qiskit. As we begin scaling the shorter cross-resonance
$R_{zx}\bigl{(}\pm\frac{\pi}{4}\bigr{)}$ pulses, sQueeze shows a 2.36$\times$
speed-up over Qiskit and that it is possible to implement accurate gates up to
3.08$\times$ faster. Compared to Earnest, sQueeze achieves an average speed-up
of $7\%$ with a maximum observed reduction in the pulse duration of $29.7\%$.

Backend | Qubit Pair |  $R_{zx}(\theta)$ Schedule Duration ($\mathtt{dt}$) | Improvement vs Qiskit
---|---|---|---
Qiskit | Earnest | sQueeze | Earnest | sQueeze
Lima | (0,1) | 3072 | 1398.4 | 1338.9 |  2.20$\times$ | 2.29$\times$
| (2,1) | 3008 | 1368.0 | 1278.4 |  2.20$\times$ | 2.35$\times$
| (3,1) | 4480 | 2089.3 | 1867.5 |  2.14$\times$ | 2.40$\times$
| (4,3) | 4672 | 2185.3 | 2057.3 |  2.14$\times$ | 2.27$\times$
Manila | (0,1) | 2816 | 1276.2 | 1245.4 |  2.21$\times$ | 2.26$\times$
| (1,2) | 4544 | 2121.3 | 1964.5 |  2.14$\times$ | 2.31$\times$
| (2,3) | 3520 | 1616.6 | 1491.8 |  2.18$\times$ | 2.36$\times$
| (4,3) | 3008 | 1368.0 | 1275.2 |  2.20$\times$ | 2.36$\times$
Nairobi | (0,1) | 2560 | 1154.9 | 1068.5 |  2.22$\times$ | 2.40$\times$
| (1,3) | 2752 | 1245.4 | 1183.7 |  2.21$\times$ | 2.32$\times$
| (2,1) | 3840 | 1773.8 | 1246.1 |  2.16$\times$ | 3.08$\times$
| (5,3) | 2496 | 1125.4 | 1094.7 |  2.22$\times$ | 2.28$\times$
| (5,4) | 2816 | 1276.2 | 1183.7 |  2.21$\times$ | 2.38$\times$
| (6,5) | 3072 | 1398.4 | 1365.4 |  2.20$\times$ | 2.25$\times$
Quito | (0,1) | 2432 | 1096.0 | 1068.5 |  2.22$\times$ | 2.28$\times$
| (1,3) | 3328 | 1523.2 | 1429.1 |  2.18$\times$ | 2.33$\times$
| (2,1) | 2688 | 1215.4 | 1155.5 |  2.21$\times$ | 2.33$\times$
| (3,4) | 2816 | 1276.2 | 1247.7 |  2.21$\times$ | 2.26$\times$
Average | - | 3217.8 | 1472.7 | 1364.6 |  2.19$\times$ | 2.36$\times$
Table 5. $R_{zx}(\theta)$ schedule durations based on the average length of
100 $R_{zx}(\theta)$ circuits for $0\leq\theta\leq\pi$.

####  Toffoli Benchmarks

Using the new direct $R_{zx}(\theta)$, $R_{x}(\theta)$, and faster CNOTs, we
demonstrate the improvement for the larger Toffoli gate. We test the
performance over the $X,Y,$ and $Z$ computational basis states. We test
sQueeze over all qubit allocations on the benchmark devices excluding IBM
Belem. The errors over the $X$, $Y$, and $Z$ basis states were similar with a
mean of $5.1\%$ and range of $3.6-7.1\%$ over 20 million shots.

We additionally compare the performance of sQueeze to current Toffoli
implementations by measuring the 1-norm distance from the ideal probability
distribution for the full range of $Z$ basis states, noting that Earnest and
Gokhale do not provide separate implementations of Toffoli gates. sQueeze
demonstrates an average error of $3.92\%$ compared to $4.65\%$ for Qiskit over
209 million shots in Fig. 19. sQueeze is $15.8\%$ more accurate than Qiskit on
average and achieves up to a $29.0\%$ improvement for the $\ket{000}$ state.
Moreover, sQueeze achieves better fidelity Toffoli gates than Qiskit for all
devices, reaching an average $20.22\%$ improvement for IBM Nairobi as shown in
Table 6.

Figure 19. The accuracy of the Toffoli gate, testing all possible qubit allocations for the $Z$ basis over 209 million shots. Device | Mean Toffoli Error (%) | Improvement v. Qiskit | Speed-up v. Qiskit
---|---|---|---
sQueeze |  Qiskit
Lima |  4.24 $\pm$ 0.47 |  4.81 $\pm$ 0.48 | 11.77% | 1.25$\times$
Manila |  4.04 $\pm$ 0.66 |  4.76 $\pm$ 0.68 |  15.22% | 1.16$\times$
Nairobi |  3.52 $\pm$ 0.11 |  4.41 $\pm$ 0.12 |  20.22% | 1.13$\times$
Quito |  3.87 $\pm$ 0.57 |  4.63 $\pm$ 0.57 |  16.39% | 1.18$\times$
Average |  3.92 $\pm$ 0.31 |  4.65 $\pm$ 0.18 |  15.80% | 1.18$\times$
Table 6. The mean Toffoli error and duration speed-up based on every possible
qubit allocation and 209 million shots.

We next consider the shorter schedule durations of the higher fidelity Toffoli
gates. To compare the schedule durations we generate a Toffoli gate for each
possible qubit allocation on all benchmark devices excluding IBM Belem.
sQueeze achieves up to a 2.4$\times$ speed-up, namely for Lima qubit
allocation (3, 1, 0). The optimal sQueeze schedule is $18,786.5\,\mathtt{dt}$,
in contrast to Qiskit’s schedule which is $22,277.9\,\mathtt{dt}$ on average.
This is a 1.18$\times$ speed-up for sQueeze, as seen in Table 6.
Interestingly, the 15.7% reduction in schedule duration on average is matched
with a 15.8% decrease in error. Therefore, sQueeze demonstrates that faster
and higher fidelity Toffoli gates can be obtained by using schedule duration
as a heuristic for accuracy when selecting a Toffoli decomposition.

To use this work without additional routing and mapping methods, the fastest
average method per device can be used as the default in place of Qiskit’s
current implementation. Consequently, Toffoli gates can be sped-up by
$1.08\times$ for Lima by simply choosing the decomposition in Fig. 10(b) as
the default.

###  Quantum Algorithm Benchmarks

Using sQueeze’s higher fidelity and faster gates, we demonstrate that these
pulses also work well when used in larger circuits. The fidelity results are
listed in Table 1 and for an expanded set of results on a per device basis see
Appendix A.2. A particularly strong improvement is exhibited in the QAOA
benchmark where sQueeze demonstrates an average $23.27\%$ increase in circuit
fidelity over Qiskit. sQueeze demonstrates an approximately equal or better
fidelity and the shortest schedule durations for all benchmarks tested.

####  Quantum Approximate Optimization Algorithm (QAOA)

We perform circuit fidelity benchmarks between sQueeze and the three other
state-of-the-art methods using the 1-norm distance between the measurement
results and the ideal probability distribution for each circuit. We test 5 and
7 qubit bipartite input graphs for QAOA to create distinct output probability
distributions over all benchmark devices (excepting Belem) for a total 14.4
million shots. For the circuits tested, QAOA requires at least 30 circuit
executions per test, and typically ran for 24-30 hours before the classical
optimiser terminated. sQueeze demonstrates an average error rate for each
circuit execution of $40.53\%$ compared to $48.22\%$ (Earnest), $52.08\%$
(Gokhale) and $52.82\%$ (Qiskit) as seen in Fig. 20(a). This represents a
$22.8\%$ mean improvement compared to Qiskit and up to a $39.6\%$ improvement
for the Manila device. This benchmark also demonstrates a $16.4\%$ improvement
over Earnest by combining our dynamic $R_{x}$ and $R_{zx}$ gates, despite
recording similar accuracy for the $R_{zx}$ gates as discussed in Sec. 6.1.2.
This demonstrates the benefits of sQueeze’s asynchronous calibration and its
ability to track drifts in error rates on NISQ devices.

(a) Mean error

(b) Schedule duration

Figure 20. QAOA results over 14.4 million shots and all benchmark devices
excluding IBM Belem.

To quantify the improvement in schedule duration, we compared circuits for
connected input graphs with $n-1$ edges for vertices $1\leq n\leq 7$. The
schedule lengths averaged over all benchmark devices are shown in Fig. 20(b).

####  Randomised Benchmarking (RB)

To simulate a random circuit and check the performance in an arbitrary basis,
we perform randomised benchmarking as described in Sec. 5. We test random
single-qubit SU(2) gates, and random two-qubit SU(4) gates over all benchmark
devices and circuits of size $n$, where $n$ is the number of qubits on the
device. For single-qubit SU(2) gates the average gate error rates for each
method are $12.40\%$ (sQueeze), $12.39\%$ (Gokhale), $12.45\%$ (Qiskit)
showing that all methods perform equally well for SU(2) gates. However, as
previously discussed sQueeze SU(2) gates are approximately twice as fast as
Gokhale’s, which are themselves more than twice as fast as Qiskit. This can be
seen in Fig. 21(a) where sQueeze achieves a $4.14\times$ speed-up relative to
Qiskit and $2.05\times$ speed-up compared to Gokhale.

(a) SU(2) gates

(b) SU(4) gates

Figure 21. RB durations averaged over all benchmark devices.

Performing randomised benchmarking using random SU(4) gates we observe a mean
gate error rate of $4.42\%$ (sQueeze), $4.64\%$ (Earnest), $6.14\%$ (Gokhale)
and $5.83\%$ (Qiskit) as seen in Table A.2. To measure the average schedule
duration, 1000 random RB circuits were generated for every benchmark device
and converted into hardware compliant circuits. The schedule durations for
these circuits can be seen in Fig. 21(b). For these RB circuits sQueeze
achieves a speed-up of $1.56\times$ compared to Qiskit and $1.11\times$
compared to Earnest.

####  Other Quantum Benchmarks

We test the remaining three benchmarks QFT, BV, and the CDKM ripple carry
adder and report similar fidelities. We test all benchmark devices for the
circuits specified in Sec. 5 and measure error as the 1-norm distance from the
ideal probability distribution, as seen in Table 1. Testing QFT we observe
mean errors of 67.4% (sQueeze), 67.5% (Earnest), 69.0% (Gokhale) and 68.9%
(Qiskit). sQueeze demonstrates a 2.2% reduction in error compared to Qiskit.
The BV circuits perform similarly for all methods with average error of 25.8%
(sQueeze), 26.1% (Earnest), 26.0% (Gokhale), which are well within one
standard deviation of Qiskit’s error  $25.7\pm 10.1$%. The same is observed
for CDKM, with mean errors of 29.26% (sQueeze), 29.64% (Earnest), and 29.31%
(Gokhale), which are again well within one standard deviation of Qiskit’s mean
error of $29.25\pm 16.39$%. An expanded set of results per device can be found
in Table A.2. For these benchmarks, sQueeze produces faster pulse schedules
for each circuit, as summarised in Table 2. As QFT is dominated by $n/2(n-1)$
controlled-phase gates, sQueeze can achieve a speed-up of 1.34$\times$ over
Qiskit for a 7-bit input string. BV is a simple circuit only containing $H$
gates and CNOT gates, for which sQueeze achieves a modest mean speed-up of
1.05$\times$. For the CDKM adders, Qiskit, Earnest, and Gokhale all have equal
schedule durations as their $X$, Toffoli and CNOT gates are all equivalent. As
the number of Toffoli gates increases by $2n+1$ with each additional adder
bit, Toffoli costs dominate the execution time and sQueeze achieves a mean
speed-up of 1.10$\times$ for each Toffoli.

##  Conclusion

sQueeze demonstrates the benefits of new live calibration techniques which use
local searches starting at the device’s initial calibrated pulse parameters.
By adding parameterised $R_{x}(\theta)$ and $R_{zx}(\theta)$ we achieve up to
a 39.6% reduction in error for near-term quantum algorithms. We increase the
$R_{x}(\theta)$ fidelity by 52.7% on average and provide a 4.12$\times$ speed-
up compared to standard quantum compilation techniques. $R_{zx}(\theta)$ are
22.63% more accurate and 2.36$\times$ faster on average.

The calibration server currently executes experiments for each qubit
individually, which is only feasible for small devices. Future work, could
investigate sparse calibration techniques that consider the effects of cross-
talk when running multiple qubit calibrations in a single circuit. This work
supports the importance of new compilation methods that uniquely do not
decompose Toffoli gates before qubit mapping and routing
(duckering2021orchestrated, ). Future work could extend this to consider the
additional Toffoli pulse decompositions we explore here.

## References

  * [1] Thomas Alexander, Naoki Kanazawa, Daniel J Egger, Lauren Capelluto, Christopher J Wood, Ali Javadi-Abhari, and David C McKay.  Qiskit pulse: programming quantum computers through the cloud with pulses.  Quantum Science and Technology, 5(4):044006, 2020.
  * [2] MD SAJID ANIS, Abby-Mitchell, Héctor Abraham, AduOffei, Rochisha Agarwal, Gabriele Agliardi, Merav Aharoni, Vishnu Ajith, Ismail Yunus Akhalwaya, Gadi Aleksandrowicz, Thomas Alexander, Matthew Amy, Sashwat Anagolum, Anthony-Gandon, Israel F. Araujo, Eli Arbel, Abraham Asfaw, Anish Athalye, Artur Avkhadiev, Carlos Azaustre, PRATHAMESH BHOLE, Vishal Bajpe, Abhik Banerjee, Santanu Banerjee, Will Bang, Aman Bansal, Panagiotis Barkoutsos, Ashish Barnawal, George Barron, George S. Barron, Luciano Bello, Yael Ben-Haim, M. Chandler Bennett, Daniel Bevenius, Dhruv Bhatnagar, Prakhar Bhatnagar, Arjun Bhobe, Paolo Bianchini, Lev S. Bishop, Carsten Blank, Sorin Bolos, Soham Bopardikar, Samuel Bosch, Sebastian Brandhofer, Brandon, Sergey Bravyi, Nick Bronn, Bryce-Fuller, David Bucher, Artemiy Burov, Fran Cabrera, Padraic Calpin, Lauren Capelluto, Jorge Carballo, Ginés Carrascal, Adam Carriker, Ivan Carvalho, Rishabh Chakrabarti, Adrian Chen, Chun-Fu Chen, Edward Chen, Jielun (Chris) Chen, Richard Chen, Franck Chevallier, Kartik Chinda, Rathish Cholarajan, Jerry M. Chow, Spencer Churchill, CisterMoke, Christian Claus, Christian Clauss, Caleb Clothier, Romilly Cocking, Ryan Cocuzzo, Jordan Connor, Filipe Correa, Zachary Crockett, Abigail J. Cross, Andrew W. Cross, Simon Cross, Juan Cruz-Benito, Chris Culver, Antonio D. Córcoles-Gonzales, Navaneeth D, Sean Dague, Tareq El Dandachi, Animesh N Dangwal, Jonathan Daniel, Marcus Daniels, Matthieu Dartiailh, Abdón Rodríguez Davila, Faisal Debouni, Anton Dekusar, Amol Deshmukh, Mohit Deshpande, Delton Ding, Jun Doi, Eli M. Dow, Patrick Downing, Eric Drechsler, Marc Sanz Drudis, Eugene Dumitrescu, Karel Dumon, Ivan Duran, Kareem EL-Safty, Eric Eastman, Grant Eberle, Amir Ebrahimi, Pieter Eendebak, Daniel Egger, ElePT, Iman Elsayed, Emilio, Alberto Espiricueta, Mark Everitt, Davide Facoetti, Farida, Paco Martín Fernández, Samuele Ferracin, Davide Ferrari, Axel Hernández Ferrera, Romain Fouilland, Albert Frisch, Andreas Fuhrer, Bryce Fuller, MELVIN GEORGE, Julien Gacon, Borja Godoy Gago, Claudio Gambella, Jay M. Gambetta, Adhisha Gammanpila, Luis Garcia, Tanya Garg, Shelly Garion, James R. Garrison, Jim Garrison, Tim Gates, Gian Gentinetta, Hristo Georgiev, Leron Gil, Austin Gilliam, Aditya Giridharan, Glen, Juan Gomez-Mosquera, Gonzalo, Salvador de la Puente González, Jesse Gorzinski, Ian Gould, Donny Greenberg, Dmitry Grinko, Wen Guan, Dani Guijo, Guillermo-Mijares-Vilarino, John A. Gunnels, Harshit Gupta, Naman Gupta, Jakob M. Günther, Mikael Haglund, Isabel Haide, Ikko Hamamura, Omar Costa Hamido, Frank Harkins, Kevin Hartman, Areeq Hasan, Vojtech Havlicek, Joe Hellmers, Łukasz Herok, Ryan Hill, Stefan Hillmich, Colin Hong, Hiroshi Horii, Connor Howington, Shaohan Hu, Wei Hu, Chih-Han Huang, Junye Huang, Rolf Huisman, Haruki Imai, Takashi Imamichi, Kazuaki Ishizaki, Ishwor, Raban Iten, Toshinari Itoko, Alexander Ivrii, Ali Javadi, Ali Javadi-Abhari, Wahaj Javed, Qian Jianhua, Madhav Jivrajani, Kiran Johns, Scott Johnstun, Jonathan-Shoemaker, JosDenmark, JoshDumo, John Judge, Tal Kachmann, Akshay Kale, Naoki Kanazawa, Jessica Kane, Kang-Bae, Annanay Kapila, Anton Karazeev, Paul Kassebaum, Tobias Kehrer, Josh Kelso, Scott Kelso, Hugo van Kemenade, Vismai Khanderao, Spencer King, Yuri Kobayashi, Kovi11Day, Arseny Kovyrshin, Rajiv Krishnakumar, Pradeep Krishnamurthy, Vivek Krishnan, Kevin Krsulich, Prasad Kumkar, Gawel Kus, Ryan LaRose, Enrique Lacal, Raphaël Lambert, Haggai Landa, John Lapeyre, Joe Latone, Scott Lawrence, Christina Lee, Gushu Li, Tan Jun Liang, Jake Lishman, Dennis Liu, Peng Liu, Lolcroc, Abhishek K M, Liam Madden, Yunho Maeng, Saurav Maheshkar, Kahan Majmudar, Aleksei Malyshev, Mohamed El Mandouh, Joshua Manela, Manjula, Jakub Marecek, Manoel Marques, Kunal Marwaha, Dmitri Maslov, Paweł Maszota, Dolph Mathews, Atsushi Matsuo, Farai Mazhandu, Doug McClure, Maureen McElaney, Joseph McElroy, Cameron McGarry, David McKay, Dan McPherson, Srujan Meesala, Dekel Meirom, Corey Mendell, Thomas Metcalfe, Martin Mevissen, Andrew Meyer, Antonio Mezzacapo, Rohit Midha, Declan Millar, Daniel Miller, Hannah Miller, Zlatko Minev, Abby Mitchell, Nikolaj Moll, Alejandro Montanez, Gabriel Monteiro, Michael Duane Mooring, Renier Morales, Niall Moran, David Morcuende, Seif Mostafa, Mario Motta, Romain Moyard, Prakash Murali, Daiki Murata, Jan Müggenburg, Tristan NEMOZ, David Nadlinger, Ken Nakanishi, Giacomo Nannicini, Paul Nation, Edwin Navarro, Yehuda Naveh, Scott Wyman Neagle, Patrick Neuweiler, Aziz Ngoueya, Thien Nguyen, Johan Nicander, Nick-Singstock, Pradeep Niroula, Hassi Norlen, NuoWenLei, Lee James O’Riordan, Oluwatobi Ogunbayo, Pauline Ollitrault, Tamiya Onodera, Raul Otaolea, Steven Oud, Dan Padilha, Hanhee Paik, Soham Pal, Yuchen Pang, Ashish Panigrahi, Vincent R. Pascuzzi, Simone Perriello, Eric Peterson, Anna Phan, Kuba Pilch, Francesco Piro, Marco Pistoia, Christophe Piveteau, Julia Plewa, Pierre Pocreau, Clemens Possel, Alejandro Pozas-Kerstjens, Rafał Pracht, Milos Prokop, Viktor Prutyanov, Sumit Puri, Daniel Puzzuoli, Pythonix, Jesús Pérez, Quant02, Quintiii, Rafey Iqbal Rahman, Arun Raja, Roshan Rajeev, Isha Rajput, Nipun Ramagiri, Anirudh Rao, Rudy Raymond, Oliver Reardon-Smith, Rafael Martín-Cuevas Redondo, Max Reuter, Julia Rice, Matt Riedemann, Rietesh, Drew Risinger, Pedro Rivero, Marcello La Rocca, Diego M. Rodríguez, RohithKarur, Ben Rosand, Max Rossmannek, Mingi Ryu, Tharrmashastha SAPV, Nahum Rosa Cruz Sa, Arijit Saha, Abdullah Ash-Saki, Sankalp Sanand, Martin Sandberg, Hirmay Sandesara, Ritvik Sapra, Hayk Sargsyan, Aniruddha Sarkar, Ninad Sathaye, Niko Savola, Bruno Schmitt, Chris Schnabel, Zachary Schoenfeld, Travis L. Scholten, Eddie Schoute, Mark Schulterbrandt, Joachim Schwarm, James Seaward, Sergi, Ismael Faro Sertage, Kanav Setia, Freya Shah, Nathan Shammah, Will Shanks, Rohan Sharma, Polly Shaw, Yunong Shi, Jonathan Shoemaker, Adenilton Silva, Andrea Simonetto, Deeksha Singh, Divyanshu Singh, Parmeet Singh, Phattharaporn Singkanipa, Yukio Siraichi, Siri, Jesus Sistos, Jesús Sistos, Iskandar Sitdikov, Seyon Sivarajah, Slavikmew, Magnus Berg Sletfjerding, John A. Smolin, Mathias Soeken, Igor Olegovich Sokolov, Igor Sokolov, Vicente P. Soloviev, SooluThomas, Starfish, Dominik Steenken, Matt Stypulkoski, Adrien Suau, Shaojun Sun, Kevin J. Sung, Makoto Suwama, Oskar Słowik, Rohit Taeja, Hitomi Takahashi, Tanvesh Takawale, Ivano Tavernelli, Charles Taylor, Pete Taylour, Soolu Thomas, Kevin Tian, Mathieu Tillet, Maddy Tod, Miroslav Tomasik, Caroline Tornow, Enrique de la Torre, Juan Luis Sánchez Toural, Kenso Trabing, Matthew Treinish, Dimitar Trenev, TrishaPe, Felix Truger, Georgios Tsilimigkounakis, Davindra Tulsi, Doğukan Tuna, Wes Turner, Yotam Vaknin, Carmen Recio Valcarce, Francois Varchon, Adish Vartak, Almudena Carrera Vazquez, Prajjwal Vijaywargiya, Victor Villar, Bhargav Vishnu, Desiree Vogt-Lee, Christophe Vuillot, James Weaver, Johannes Weidenfeller, Rafal Wieczorek, Jonathan A. Wildstrom, Jessica Wilson, Erick Winston, WinterSoldier, Jack J. Woehr, Stefan Woerner, Ryan Woo, Christopher J. Wood, Ryan Wood, Steve Wood, James Wootton, Matt Wright, Lucy Xing, Jintao YU, Yaiza, Bo Yang, Unchun Yang, Jimmy Yao, Daniyar Yeralin, Ryota Yonekura, David Yonge-Mallo, Ryuhei Yoshida, Richard Young, Jessie Yu, Lebin Yu, Yuma-Nakamura, Christopher Zachow, Laura Zdanski, Helena Zhang, Iulia Zidaru, Bastian Zimmermann, Christa Zoufal, aeddins ibm, alexzhang13, b63, bartek bartlomiej, bcamorrison, brandhsn, chetmurthy, choerst ibm, dalin27, deeplokhande, dekel.meirom, dime10, dlasecki, ehchen, ewinston, fanizzamarco, fs1132429, gadial, galeinston, georgezhou20, georgios ts, gruu, hhorii, hhyap, hykavitha, itoko, jeppevinkel, jessica angel7, jezerjojo14, jliu45, johannesgreiner, jscott2, kUmezawa, klinvill, krutik2966, ma5x, michelle4654, msuwama, nico lgrs, nrhawkins, ntgiwsvp, ordmoj, sagar pahwa, pritamsinha2304, rithikaadiga, ryancocuzzo, saktar unr, saswati qiskit, sebastian mair, septembrr, sethmerkel, sg495, shaashwat, smturro2, sternparky, strickroman, tigerjack, tsura crisaldo, upsideon, vadebayo49, welien, willhbang, wmurphy collabstar, yang.luh, yuri@FreeBSD, and Mantas Čepulkovskis.  Qiskit: An open-source framework for quantum computing, 2021.
  * [3] Adriano Barenco, Charles H Bennett, Richard Cleve, David P DiVincenzo, Norman Margolus, Peter Shor, Tycho Sleator, John A Smolin, and Harald Weinfurter.  Elementary gates for quantum computation.  Physical review A, 52(5):3457, 1995.
  * [4] Ethan Bernstein and Umesh Vazirani.  Quantum complexity theory.  SIAM Journal on computing, 26(5):1411–1473, 1997.
  * [5] Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, and Seth Lloyd.  Quantum machine learning.  Nature, 549(7671):195–202, 2017.
  * [6] Alex Bocharov and Krysta M Svore.  Resource-optimal single-qubit quantum circuits.  Physical Review Letters, 109(19):190501, 2012.
  * [7] Jerry M Chow, Antonio D Córcoles, Jay M Gambetta, Chad Rigetti, Blake R Johnson, John A Smolin, Jim R Rozen, George A Keefe, Mary B Rothwell, Mark B Ketchen, et al.  Simple all-microwave entangling gate for fixed-frequency superconducting qubits.  Physical review letters, 107(8):080502, 2011.
  * [8] Steven A Cuccaro, Thomas G Draper, Samuel A Kutin, and David Petrie Moulton.  A new quantum ripple-carry addition circuit.  arXiv preprint quant-ph/0410184, 2004.
  * [9] Marc G Davis, Ethan Smith, Ana Tudor, Koushik Sen, Irfan Siddiqi, and Costin Iancu.  Towards optimal topology aware quantum circuit synthesis.  In 2020 IEEE International Conference on Quantum Computing and Engineering (QCE), pages 223–234. IEEE, 2020.
  * [10] Christopher M Dawson and Michael A Nielsen.  The solovay-kitaev algorithm.  arXiv preprint quant-ph/0505030, 2005.
  * [11] P De Fouquieres, SG Schirmer, SJ Glaser, and Ilya Kuprov.  Second order gradient ascent pulse engineering.  Journal of Magnetic Resonance, 212(2):412–417, 2011.
  * [12] Petar M Djuric, Jayesh H Kotecha, Jianqui Zhang, Yufei Huang, Tadesse Ghirmai, Mónica F Bugallo, and Joaquin Miguez.  Particle filtering.  IEEE signal processing magazine, 20(5):19–38, 2003.
  * [13] Casey Duckering, Jonathan M Baker, Andrew Litteken, and Frederic T Chong.  Orchestrated trios: compiling for efficient communication in quantum programs with 3-qubit gates.  In Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, pages 375–385, 2021.
  * [14] Nathan Earnest, Caroline Tornow, and Daniel J Egger.  Pulse-efficient circuit transpilation for quantum applications on cross-resonance-based hardware.  Physical Review Research, 3(4):043088, 2021.
  * [15] Daniel J Egger, Claudio Gambella, Jakub Marecek, Scott McFaddin, Martin Mevissen, Rudy Raymond, Andrea Simonetto, Stefan Woerner, and Elena Yndurain.  Quantum computing for finance: State-of-the-art and future prospects.  IEEE Transactions on Quantum Engineering, 1:1–24, 2020.
  * [16] Daniel J Egger, Jakub Mareček, and Stefan Woerner.  Warm-starting quantum optimization.  Quantum, 5:479, 2021.
  * [17] Edward Farhi, Jeffrey Goldstone, and Sam Gutmann.  A quantum approximate optimization algorithm.  arXiv preprint arXiv:1411.4028, 2014.
  * [18] Austin G Fowler.  Constructing arbitrary steane code single logical qubit fault-tolerant gates.  arXiv preprint quant-ph/0411206, 2004.
  * [19] Brooks Foxen, Charles Neill, Andrew Dunsworth, Pedram Roushan, Ben Chiaro, Anthony Megrant, Julian Kelly, Zijun Chen, Kevin Satzinger, Rami Barends, et al.  Demonstrating a continuous set of two-qubit gates for near-term quantum algorithms.  Physical Review Letters, 125(12):120504, 2020.
  * [20] Steffen J Glaser, Ugo Boscain, Tommaso Calarco, Christiane P Koch, Walter Köckenberger, Ronnie Kosloff, Ilya Kuprov, Burkhard Luy, Sophie Schirmer, Thomas Schulte-Herbrüggen, et al.  Training schrödinger’s cat: quantum optimal control.  The European Physical Journal D, 69(12):1–24, 2015.
  * [21] Pranav Gokhale, Ali Javadi-Abhari, Nathan Earnest, Yunong Shi, and Frederic T Chong.  Optimized quantum compilation for near-term algorithms with openpulse.  In 2020 53rd Annual IEEE/ACM International Symposium on Microarchitecture (MICRO), pages 186–200. IEEE, 2020.
  * [22] Christopher Granade, Christopher Ferrie, and Steven T Flammia.  Practical adaptive quantum tomography.  New Journal of Physics, 19(11):113017, nov 2017.
  * [23] Christopher E Granade, Christopher Ferrie, Nathan Wiebe, and D G Cory.  Robust online hamiltonian learning.  New Journal of Physics, 14(10):103013, oct 2012.
  * [24] Daniel Greenbaum.  Introduction to quantum gate set tomography, 2015.
  * [25] Vojtěch Havlíček, Antonio D Córcoles, Kristan Temme, Aram W Harrow, Abhinav Kandala, Jerry M Chow, and Jay M Gambetta.  Supervised learning with quantum-enhanced feature spaces.  Nature, 567(7747):209–212, 2019.
  * [26] M Howard, J Twamley, C Wittmann, T Gaebel, F Jelezko, and J Wrachtrup.  Quantum process tomography and linblad estimation of a solid-state qubit.  New Journal of Physics, 8(3):33–33, mar 2006.
  * [27] W Jakubetz, B Just, J Manz, and HJ Schreier.  Mechanism of state-selective vibrational excitation by an infrared picosecond laser pulse studied by two techniques: fast fourier transform propagation of a molecular wave packet and analysis of the corresponding vibrational transitions.  Journal of Physical Chemistry, 94(6):2294–2300, 1990.
  * [28] Navin Khaneja and Steffen Glaser.  Cartan decomposition of su (2^ n), constructive controllability of spin systems and universal quantum computing.  arXiv preprint quant-ph/0010100, 2000.
  * [29] Vadym Kliuchnikov, Dmitri Maslov, and Michele Mosca.  Practical approximation of single-qubit unitaries by single-qubit quantum clifford and t circuits.  IEEE Transactions on Computers, 65(1):161–172, 2015.
  * [30] Emanuel Knill, Dietrich Leibfried, Rolf Reichle, Joe Britton, R Brad Blakestad, John D Jost, Chris Langer, Roee Ozeri, Signe Seidelin, and David J Wineland.  Randomized benchmarking of quantum gates.  Physical Review A, 77(1):012307, 2008.
  * [31] Vadim Krotov.  Global methods in optimal control theory, volume 195.  CRC Press, 1995.
  * [32] Kenneth Levenberg.  A method for the solution of certain non-linear problems in least squares.  Quarterly of applied mathematics, 2(2):164–168, 1944.
  * [33] Gushu Li, Yufei Ding, and Yuan Xie.  Tackling the qubit mapping problem for nisq-era quantum devices.  In Proceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems, pages 1001–1014, 2019.
  * [34] Ken Matsumoto and Kazuyuki Amano.  Representation of quantum circuits with clifford and $\pi/8$ gates.  arXiv preprint arXiv:0806.3834, 2008.
  * [35] David C McKay, Christopher J Wood, Sarah Sheldon, Jerry M Chow, and Jay M Gambetta.  Efficient z gates for quantum computing.  Physical Review A, 96(2):022330, 2017.
  * [36] Seth T. Merkel, Jay M. Gambetta, John A. Smolin, Stefano Poletto, Antonio D. Córcoles, Blake R. Johnson, Colm A. Ryan, and Matthias Steffen.  Self-consistent quantum process tomography.  Phys. Rev. A, 87:062119, Jun 2013.
  * [37] Nikolaj Moll, Panagiotis Barkoutsos, Lev S Bishop, Jerry M Chow, Andrew Cross, Daniel J Egger, Stefan Filipp, Andreas Fuhrer, Jay M Gambetta, Marc Ganzhorn, et al.  Quantum optimization using variational algorithms on near-term quantum devices.  Quantum Science and Technology, 3(3):030503, 2018.
  * [38] Gary J Mooney, Charles D Hill, and Lloyd CL Hollenberg.  Cost-optimal single-qubit gate synthesis in the clifford hierarchy.  Quantum, 5:396, 2021.
  * [39] Felix Motzoi, Jay M Gambetta, Patrick Rebentrost, and Frank K Wilhelm.  Simple pulses for elimination of leakage in weakly nonlinear qubits.  Physical review letters, 103(11):110501, 2009.
  * [40] Michael A. Nielsen and Isaac L. Chuang.  Quantum Computation and Quantum Information: 10th Anniversary Edition.  Cambridge University Press, USA, 10th edition, 2011.
  * [41] Jeremy L O’Brien, Geoff J Pryde, Alexei Gilchrist, Daniel FV James, Nathan K Langford, Timothy C Ralph, and Andrew G White.  Quantum process tomography of a controlled-not gate.  Physical review letters, 93(8):080502, 2004.
  * [42] Román Orús, Samuel Mugel, and Enrique Lizaso.  Quantum computing for finance: Overview and prospects.  Reviews in Physics, 4:100028, 2019.
  * [43] Michael J Peterer, Samuel J Bader, Xiaoyue Jin, Fei Yan, Archana Kamal, Theodore J Gudmundsen, Peter J Leek, Terry P Orlando, William D Oliver, and Simon Gustavsson.  Coherence and decay of higher energy levels of a superconducting transmon qubit.  Physical review letters, 114(1):010501, 2015.
  * [44] John Preskill.  Quantum computing in the nisq era and beyond.  Quantum, 2:79, 2018.
  * [45] Qiskit.  Qiskit equivalence library source code, 2022.  https://github.com/Qiskit/qiskit-terra/blob/main/qiskit/circuit/library/standard_gates/equivalence_library.py.
  * [46] Sarah Sheldon, Easwar Magesan, Jerry M Chow, and Jay M Gambetta.  Procedure for systematically tuning up cross-talk in the cross-resonance gate.  Physical Review A, 93(6):060302, 2016.
  * [47] Neereja Sundaresan, Isaac Lauer, Emily Pritchett, Easwar Magesan, Petar Jurcevic, and Jay M Gambetta.  Reducing unitary and spectator errors in cross resonance with optimized rotary echoes.  PRX Quantum, 1(2):020318, 2020.
  * [48] Yaakov S Weinstein, MA Pravia, EM Fortunato, Seth Lloyd, and David G Cory.  Implementation of the quantum fourier transform.  Physical review letters, 86(9):1889, 2001.
  * [49] Jun Zhang, Jiri Vala, Shankar Sastry, and K Birgitta Whaley.  Geometric theory of nonlocal two-qubit operations.  Physical Review A, 67(4):042313, 2003.
  * [50] Jun Zhang, Jiri Vala, Shankar Sastry, and K Birgitta Whaley.  Optimal quantum circuit synthesis from controlled-unitary gates.  Physical Review A, 69(4):042309, 2004.

##  Appendix A Appendix

###  Optimal Single-Qubit Pulse Duration

IBM Device | Qubit | Qiskit’s $X$ Pulse Amplitude | sQueeze Pulse Duration $\mathtt{dt}$
---|---|---|---
Belem | 0 | 0.2511 $\pm$ 0.0049 | 80
1 | 0.2441 $\pm$ 0.0037 | 64
2 | 0.0998 $\pm$ 0.0017 | 80
3 | 0.2568 $\pm$ 0.0202 | 96
4 | 0.3223 $\pm$ 0.0103 | 96
Lima | 0 | 0.1199 $\pm$ 0.0023 | 64
1 | 0.1465 $\pm$ 0.0022 | 64
2 | 0.1373 $\pm$ 0.0024 | 64
3 | 0.1262 $\pm$ 0.0022 | 64
4 | 0.1261 $\pm$ 0.0020 | 64
Manila | 0 | 0.2034 $\pm$ 0.0026 | 80
1 | 0.1992 $\pm$ 0.0029 | 80
2 | 0.2037 $\pm$ 0.0026 | 80
3 | 0.1997 $\pm$ 0.0024 | 80
4 | 0.2002 $\pm$ 0.0028 | 80
Quito | 0 | 0.1728 $\pm$ 0.0034 | 80
1 | 0.1439 $\pm$ 0.0017 | 64
2 | 0.1855 $\pm$ 0.0029 | 80
3 | 0.1776 $\pm$ 0.0026 | 80
4 | 0.4139 $\pm$ 0.0021 | 112
Nairobi | 0 | 0.1396 $\pm$ 0.0002 | 64
1 | 0.1630 $\pm$ 0.0002 | 80
2 | 0.2077 $\pm$ 0.0003 | 80
3 | 0.1984 $\pm$ 0.0003 | 80
4 | 0.2061 $\pm$ 0.0003 | 80
5 | 0.1994 $\pm$ 0.0003 | 80
6 | 0.1976 $\pm$ 0.0003 | 80
Average | - | - | 77.63 $\pm$ 11.49
Table 7. The optimal sQueeze pulse duration for each qubit. The mean and
standard deviation of Qiskit’s calibrated $X$ gate amplitude over four months
show there is little variation for each qubit.

###  Benchmark Performance per Device

Benchmark | Device | Mean Benchmark Error (%) | Improvement vs. Qiskit
---|---|---|---
sQueeze | Earnest | Gokhale | Qiskit | sQueeze | Earnest | Gokhale
QAOA | Lima |  37.2 $\pm$ 5.7 |  39.9 $\pm$ 4.9 |  48.0 $\pm$ 9.4 |  47.4 $\pm$ 28.5 |  21.6 % | 15.8 % | -1.2 %
| Manila |  26.0 $\pm$ 0.0 |  31.8 $\pm$ 9.4 |  44.0 $\pm$ 4.5 |  43.1 $\pm$ 11.6 |  39.6 % | 26.2 % | -2.1 %
| Nairobi |  60.8 $\pm$ 3.1 |  79.5 $\pm$ 1.5 |  76.2 $\pm$ 3.5 |  76.8 $\pm$ 14.5 |  20.8 % | -3.6 % | 0.8 %
| Quito |  38.0 $\pm$ 4.3 |  41.6 $\pm$ 6.4 |  40.2 $\pm$ 8.8 |  43.9 $\pm$ 4.80 |  13.4 % | 5.3 % | 8.4 %
| Average |  40.5 $\pm$ 14.6 |  48.2 $\pm$ 21.3 |  52.1 $\pm$ 22.7 |  52.8 $\pm$ 16.1 |  23.3 % | 8.7 % | 1.2 %
RB | Lima |  4.55 $\pm$ 0.91 |  4.61 $\pm$ 0.94 |  5.72 $\pm$ 1.04 |  5.69 $\pm$ 1.08 |  20.02 % | 18.98 % | -0.51 %
| Manila |  3.69 $\pm$ 0.70 |  3.92 $\pm$ 0.77 |  5.43 $\pm$ 0.87 |  5.03 $\pm$ 0.58 |  26.66 % | 22.14 % | -7.92 %
| Nairobi |  4.73 $\pm$ 1.04 |  5.30 $\pm$ 1.09 |  7.76 $\pm$ 1.84 |  6.90 $\pm$ 1.34 |  31.49 % | 23.11 % | -12.56 %
| Quito |  4.84 $\pm$ 0.42 |  4.88 $\pm$ 0.52 |  5.84 $\pm$ 0.52 |  5.89 $\pm$ 0.50 |  17.81 % | 17.16 % | 0.80 %
| Average |  4.42 $\pm$ 0.45 |  4.64 $\pm$ 0.50 |  6.14 $\pm$ 0.76 |  5.83 $\pm$ 0.63 |  24.25 % | 20.41 % | -5.30 %
QFT | Lima |  66.7 $\pm$ 42.7 |  66.6 $\pm$ 42.8 |  67.5 $\pm$ 42.0 |  67.1 $\pm$ 42.3 | 0.5 % |  0.7 % | -0.6 %
| Manila |  66.2 $\pm$ 43.4 |  66.4 $\pm$ 43.2 |  67.8 $\pm$ 41.8 |  68.0 $\pm$ 41.8 |  2.7 % | 2.4 % | 0.4 %
| Nairobi |  71.6 $\pm$ 40.6 |  71.9 $\pm$ 40.2 |  74.4 $\pm$ 37.8 |  74.5 $\pm$ 37.9 |  3.8 % | 3.5 % | 0.1 %
| Quito |  65.1 $\pm$ 44.5 |  65.1 $\pm$ 44.5 |  66.4 $\pm$ 43.1 |  66.2 $\pm$ 43.4 | 1.6 % |  1.6 % | -0.4 %
| Average |  67.4 $\pm$ 2.90 |  67.5 $\pm$ 3.00 |  69.0 $\pm$ 3.70 |  68.9 $\pm$ 3.80 |  2.2 % | 2.1 % | -0.1 %
BV | Lima |  18.2 $\pm$ 13.5 |  18.1 $\pm$ 13.6 |  18.4 $\pm$ 13.7 |  18.0 $\pm$ 13.5 | -1.3 % | -0.5 % | -2.0 %
| Manila |  25.2 $\pm$ 17.5 |  26.1 $\pm$ 17.4 |  25.3 $\pm$ 17.5 |  25.2 $\pm$ 17.1 |  0.0 % | -3.7 % | -0.5 %
| Nairobi |  39.4 $\pm$ 19.9 |  40.0 $\pm$ 19.7 |  40.0 $\pm$ 19.9 |  40.0 $\pm$ 19.8 |  1.5 % | 0.1 % | 0.1 %
| Quito |  20.4 $\pm$ 11.6 |  20.2 $\pm$ 11.3 |  20.3 $\pm$ 11.5 |  19.5 $\pm$ 11.2 | -4.6 % | -3.4 % | -4.2 %
| Average |  25.8 $\pm$ 9.50 |  26.1 $\pm$ 9.90 |  26.0 $\pm$ 9.80 |  25.7 $\pm$ 10.0 | -0.5 % | -1.6 % | -1.3 %
CDKM | Lima |  21.0 $\pm$ 10.8 |  21.2 $\pm$ 10.9 |  21.0 $\pm$ 10.8 |  21.0 $\pm$ 10.8 | -0.1 % | -1.0 % |  0.1 %
| Manila |  23.8 $\pm$ 11.9 |  24.3 $\pm$ 12.0 |  23.7 $\pm$ 11.7 |  23.3 $\pm$ 11.6 | -2.2 % | -4.0 % | -1.5 %
| Nairobi |  53.1 $\pm$ 20.6 |  53.7 $\pm$ 21.8 |  53.6 $\pm$ 21.8 |  53.7 $\pm$ 21.8 |  1.2 % | -0.0 % | 0.2 %
| Quito |  19.1 $\pm$ 9.80 |  19.4 $\pm$ 10.0 |  19.0 $\pm$ 9.80 |  19.0 $\pm$ 9.90 | -0.3 % | -1.9 % |  0.1 %
| Average |  29.3 $\pm$ 16.0 |  29.6 $\pm$ 16.2 |  29.3 $\pm$ 16.3 |  29.3 $\pm$ 16.4 |  0.0 % | -1.3 % | -0.2 %
Table 8. Common quantum algorithm benchmark fidelity per device. For RB, we
report the fitted mean error per gate, otherwise the error is the distance
from the ideal probability distribution. The best method is listed in bold.