# Relativistic Elastic Differential Cross Sections for Equal Mass Nuclei

C. M. Werneth  NASA Langley Research Center, 2 West Reid Street, Hampton, VA
23681  K. M. Maung  The University of Southern Mississippi, 118 College Drive,
Box 5046, Hattiesburg, MS 39406  W. P. Ford  The University of Southern
Mississippi, 118 College Drive, Box 5046, Hattiesburg, MS 39406

###### Abstract

The effects of relativistic kinematics are studied for nuclear collisions of
equal mass nuclei. It is found that the relativistic and non-relativistic
elastic scattering amplitudes are nearly indistinguishable, and, hence, the
relativistic and non-relativistic differential cross sections become
indistinguishable. These results are explained by analyzing the Lippmann-
Schwinger equation with the first order optical potential that was employed in
the calculation.

Lippmann-Schwinger Equation, Relativistic Kinematics, Elastic Differential
Cross Section

###### pacs:

24.10.Ht, 24.10.Cn, 24.10.Jv

The Lippmann-Schwinger (LS) equation for the transition amplitude is often
used to calculate nuclear cross sections Joachain . The minimum requirement
for the study of relativistic effects in the LS equation is the inclusion of
relativistic kinematics. In this letter, the effect of relativistic (REL)
kinematics in nucleus-nucleus scattering is studied, and it is found that the
scattering amplitudes calculated with REL and non-relativistic (NR) kinematics
are nearly indistinguishable for nuclear collisions of equal mass nuclei when
using the first order optical potential. It is shown that there are no
observed significant differences between the NR and REL elastic differential
cross sections for the equal mass case.

The elastic scattering amplitude is determined from the transition amplitude,
which is obtained by solving the following integral equation Joachain ,

$T_{\rm
AA}(\mathbf{k}^{\prime},\mathbf{k})=U(\mathbf{k}^{\prime},\mathbf{k})+\int\frac{U(\mathbf{k}^{\prime},\mathbf{k}^{\prime\prime})T_{\rm
AA}(\mathbf{k}^{\prime\prime},\mathbf{k})}{E_{k}-E_{k^{\prime\prime}}+i\epsilon}d\mathbf{k}^{\prime\prime},$
(1)

where $\mathbf{k}$ ($\mathbf{k}^{\prime}$) is the initial (final) relative
momentum of the projectile-target system in the center of momentum (CM) frame,
$E$ is the NR or REL total energy, $T_{\rm
AA}(\mathbf{k}^{\prime},\mathbf{k})$ is the off-shell transition amplitude,
and $U(\mathbf{k}^{\prime},\mathbf{k})$ is the optical potential. Using
factorization and on-shell approximations for central potentials, the optical
potential for projectiles and targets of equal mass is expressed as Pickle ;
Pickle2 ; Wolfe ; NASATP2014 ; WernethElArch

$U(\mathbf{k}^{\prime},\mathbf{k})=\eta{\rm A_{P}A_{T}}t_{\rm
NN}(|\mathbf{k}^{\prime}-\mathbf{k}|)\rho_{\rm
A_{P}}(|\mathbf{k}^{\prime}-\mathbf{k}|)\rho_{\rm
A_{T}}(|\mathbf{k}^{\prime}-\mathbf{k}|),$ (2)

where $\eta$ is the Möller factor Moller ; Joachain , $\rm A_{P}$ and $\rm
A_{T}$ are, respectively, the number of nucleons in the projectile and target,
$t_{\rm NN}$ is the nucleon-nucleon (NN) transition amplitude, and
$\rho(|\mathbf{k}^{\prime}-\mathbf{k}|)$ is the nuclear density of a nucleus
DeVries1 ; DeVries2 . For equal mass projectile and target nuclei ($\rm
A_{P}=A_{T}=A)$, $\eta=1$, and the optical potential is

$U(\mathbf{k}^{\prime},\mathbf{k})={\rm A}^{2}\rho^{2}_{\rm
A}(|\mathbf{k}^{\prime}-\mathbf{k}|)t_{\rm
NN}(|\mathbf{k}^{\prime}-\mathbf{k}|).$ (3)

The on-shell scattering amplitude is related to the on-shell transition
amplitude by Joachain

$f(k,k,\hat{\mathbf{k}}\cdot\hat{\mathbf{k}^{\prime}})=-(2\pi)^{2}k\frac{dk}{dE_{k}}t(k,k,\hat{\mathbf{k}^{\prime}}\cdot\hat{\mathbf{k}}).$
(4)

The off-shell scattering amplitude is defined as,

$f(\mathbf{k}^{\prime},\mathbf{k})\equiv\beta(k^{\prime})~{}t(\mathbf{k}^{\prime},\mathbf{k})~{}\beta(k),$
(5)

where

$\beta(k)=2\pi i\sqrt{k\frac{dk}{dE_{k}}},$ (6)

such that equation (4) is satisfied when the relative momentum is on-shell.

In order to show that the NR and REL elastic differential cross sections are
the same for equal mass systems, the off-shell scattering amplitudes are
obtained by using equation (5);

$\displaystyle\beta_{\rm AA}(k^{\prime})T_{\rm
AA}(\mathbf{k}^{\prime},\mathbf{k})\beta_{\rm AA}(k)$
$\displaystyle=\frac{\beta_{\rm AA}(k^{\prime})}{\beta_{\rm
NN}(\kappa^{\prime})}\beta_{\rm NN}(\kappa^{\prime})t_{\rm
NN}(|\mathbf{k}^{\prime}-\mathbf{k}|)\beta_{\rm NN}(\kappa)\frac{\beta_{\rm
AA}(k)}{\beta_{\rm
NN}(\kappa)}A^{2}\rho_{A}^{2}(|\mathbf{k}^{\prime}-\mathbf{k}|)$ (7)
$\displaystyle+{\bf P}\int\Bigg{[}\beta_{\rm AA}(k^{\prime})\frac{\beta_{\rm
NN}(\kappa^{\prime})}{\beta_{\rm
NN}(\kappa^{\prime})}t(|\mathbf{k}^{\prime}-\mathbf{k}^{\prime\prime}|)\frac{\beta_{\rm
NN}(\kappa^{\prime\prime})}{\beta_{\rm
NN}(\kappa^{\prime\prime})}A^{2}\rho^{2}_{A}(|\mathbf{k}^{\prime}-\mathbf{k}^{\prime\prime}|)$
$\displaystyle~{}~{}~{}~{}~{}~{}~{}~{}~{}\times\frac{1}{E_{k}-E_{k^{\prime\prime}}}\frac{\beta_{\rm
AA}(k^{\prime\prime})}{\beta_{\rm AA}(k^{\prime\prime})}T_{\rm
AA}(|\mathbf{k}^{\prime\prime}-\mathbf{k}|)\beta_{\rm
AA}(k)d\mathbf{k}^{\prime\prime}\Bigg{]}$
$\displaystyle-i\pi\int\Bigg{[}\beta_{\rm AA}(k^{\prime})\frac{\beta_{\rm
NN}(\kappa^{\prime})}{\beta_{\rm
NN}(\kappa^{\prime})}t(|\mathbf{k}^{\prime}-\mathbf{k}|)\frac{\beta_{\rm
NN}(\kappa^{\prime\prime})}{\beta_{\rm
NN}(\kappa^{\prime\prime})}A^{2}\rho_{A}^{2}(|\mathbf{k}^{\prime}-\mathbf{k}^{\prime\prime}|)$
$\displaystyle~{}~{}~{}~{}~{}~{}~{}~{}\times\delta\Big{(}E_{k}-E_{k^{\prime\prime}}\Big{)}\frac{\beta_{\rm
AA}(k^{\prime\prime})}{\beta_{\rm AA}(k^{\prime\prime})}T_{\rm
AA}(\mathbf{k}^{\prime\prime},\mathbf{k})\beta_{\rm
AA}(k)d\mathbf{k}^{\prime\prime}\Bigg{]},$

where

$\beta^{2}_{\rm AA}=\begin{cases}-(2\pi)^{2}\frac{{\rm A}m}{2}&\text{for the
NR case},\\\ -(2\pi)^{2}{\rm A}\frac{\sqrt{m^{2}+\kappa^{2}}}{2}&\text{for the
REL case}\end{cases}$ (8)

$\beta^{2}_{\rm NN}=\begin{cases}-(2\pi)^{2}\frac{m}{2}&\text{for the NR
case}\\\ -(2\pi)^{2}\frac{\sqrt{m^{2}+\kappa^{2}}}{2}&\text{for the REL
case},\end{cases}$ (9)

and the propagator has been expressed in terms of its principal value, ${\bf
P}$,

$\frac{1}{E_{k}-E_{k^{\prime\prime}}+i\eta}={\bf
P}\Bigg{(}\frac{1}{E_{k}-E_{k^{\prime\prime}}}\Bigg{)}-i\pi\delta(E_{k}-E_{k^{\prime\prime}}).$
(10)

The Fermi motion of the nucleons inside the nucleus is neglected; therefore,
the momentum imparted to each nucleon is $\kappa=k/{\rm A}$. The mass of the
nucleus, $M$, is approximately ${\rm A}m$, where $m$ is the average nucleon
mass.

The pole structure for NR scattering amplitude is proportional to
$1/(k^{2}-{k^{\prime\prime}}^{2})$. With REL kinematics, the propagator can be
rationalized such that the pole structure is manifestly the same as the NR
case, thus

${\bf P}\Bigg{(}\frac{1}{E_{k}-E_{k^{\prime\prime}}}\Bigg{)}=\begin{cases}{\bf
P}\Bigg{[}\frac{2\mu}{(k^{2}-{k^{\prime\prime}}^{2})}\Bigg{]}&\text{for the NR
case}\\\ {\bf
P}\Bigg{[}\Bigg{(}\frac{\sqrt{M^{2}+k^{2}}}{2}\Bigg{)}\Bigg{(}\frac{1+\sqrt{\frac{M^{2}+{k^{\prime\prime}}^{2}}{M^{2}+{k}^{2}}}}{k^{2}-{k^{\prime\prime}}^{2}}\Bigg{)}\Bigg{]}&\text{for
the REL case},\end{cases}$ (11)

where $\mu={\rm M}/2$.

Using equations (8), (9), and (11), the scattering amplitude from equation (7)
reduces to the following for on-shell scattering:

$\displaystyle F_{\rm AA}$
$\displaystyle(k,\hat{\mathbf{k}^{\prime}}\cdot\hat{\mathbf{k}})=f_{\rm
NN}(k,\hat{\mathbf{k}^{\prime}}\cdot\hat{\mathbf{k}}){\rm
A}^{3}\rho_{A}(k,\hat{\mathbf{k}^{\prime}}\cdot\hat{\mathbf{k}})$ (12)
$\displaystyle+{\bf P}\int\frac{f_{\rm
NN}(|\mathbf{k}^{\prime}-\mathbf{k}^{\prime\prime}|)h(k,k^{\prime\prime}){\rm
A}^{3}\rho_{\rm A}^{2}(|\mathbf{k}^{\prime}-\mathbf{k}^{\prime\prime}|)F_{\rm
AA}(|\mathbf{k}^{\prime\prime}-\mathbf{k}|)}{[-(2\pi)^{2}](k^{2}-{k^{\prime\prime}}^{2})}d\mathbf{k}^{\prime\prime}$
$\displaystyle-i\pi\int f_{\rm
NN}(k,\hat{\mathbf{k}^{\prime}}\cdot\hat{\mathbf{k}^{\prime\prime}}){\rm
A}^{3}\rho_{\rm
A}^{2}(k,\hat{\mathbf{k}^{\prime}}\cdot\hat{\mathbf{k}^{\prime\prime}})F_{\rm
AA}(k,\hat{\mathbf{k^{\prime\prime}}}\cdot\hat{\mathbf{k}})\frac{k}{-(2\pi)^{2}}d\Omega_{k^{\prime\prime}}$

where

$\begin{cases}h(k,k^{\prime\prime})=2&\text{for the NR case}\\\
h(k,k^{\prime\prime})=1+\sqrt{\frac{M^{2}+{k^{\prime\prime}}^{2}}{M^{2}+k^{2}}}&\text{for
the REL case}.\end{cases}$ (13)

The only difference between the two amplitudes is that
$h(k,k^{\prime\prime})=2$ in the NR case, and
$h(k,k^{\prime\prime})\rightarrow 2$ only near the elastic cut for the REL
case. The optical potential is largest near the on-shell momentum but decays
rapidly thereafter. By definition, the principal value integral is never
evaluated at $k^{\prime\prime}=k$; however, significant contributions occur
_near_ the elastic cut. Due to the rapidly decaying optical potential and
large contributions near the elastic cut, little differences are observed
between the NR and REL scattering amplitudes for projectiles and targets of
equal mass.

To illustrate these results, elastic differential cross sections are given in
Fig. 1 for 4He + 56Fe, 4He + 20Ne, 4He + 12C, and 4He + 4He reactions at a lab
projectile energy of 1 GeV/n. NR and REL elastic differential cross sections
are generated with a three-dimensional Lippmann-Schwinger (LS3D) solution
LS3D_1 ; LS3D_2 ; LS3D_3 ; LS3D_4 . See reference NASATP2014  for the explicit
form of the nuclear densities, transition amplitude, and parameterizations
that were used in the current work.

From Fig. 1, it is obvious that the NR and REL elastic differential cross
sections are different for the 4He + 56Fe, 4He + 20Ne, and 4He + 12C
reactions, where the projectile and target masses differ. It is also observed
that the largest REL difference occurs in the case of 4He + 56Fe, where the
mass difference between the projectile and target is largest. There are no
significant differences between the NR and REL results for the equal mass case
of the 4He + 4He reaction.

Next, eikonal (Eik), partial wave (PW), and LS3D codes are used to predict the
elastic differential cross sections for 20Ne + 20Ne reactions in Fig. 2 and
56Fe + 56Fe reactions in Fig. 3 with lab projectile kinetic energies of 150,
500, 1000, and 20000 MeV/n. These solution methods are fully described in
references Joachain ; LS3D_1 ; LS3D_2 ; LS3D_3 ; LS3D_4 ; Pickle ; Pickle2 ;
Wolfe ; NASATP2014 . The PW and LS3D results are generated with NR and REL
kinematics, whereas the Eik code is NR. Each figure shows that there is no
significant difference between the NR and REL elastic differential cross
sections, regardless of the energy.

In summary, it is noted that the REL propagator has pole structure that is
similar to the NR case and that the REL and NR scattering amplitudes are
approximately equal near the elastic cut. The optical potential is largest
near the on-shell momentum and decays rapidly thereafter. Consequently, the NR
and REL on-shell scattering amplitudes have been shown to be nearly
indistinguishable for projectile and target nuclei of equal mass.

## Acknowledgments

The authors would like to thank Drs. John Norbury, Steve Blattnig, Ryan
Norman, Jonathan Ransom, and Francis Badavi for reviewing this manuscript.
This work was supported by the Human Research Program under the Human
Exploration and Operations Mission Directorate of NASA and NASA grant number
NNX13AH31A.

## References

  * (1) C. J. Joachain, Quantum Collision Theory (American Elsevier, New York, 1983).
  * (2) A. Picklesimer, P. C. Tandy, R. Thaler, and D. Wolfe, Phys. Rev. C 30, 1861 (1984).
  * (3) A. Picklesimer, P. C. Tandy, R. Thaler, and D. Wolfe, Phys. Rev. C 29, 1582 (1984).
  * (4) D. H. Wolfe, Ph.D. thesis, Kent State University, 1983.
  * (5) C. M. Werneth et al., Elastic Differential Cross Sections, NASA Technical Publication 2014-218529.
  * (6) C. M. Werneth et al., arXiv:1409.3510 [nucl-th], 2014.
  * (7) C. Möller, K. Dan. Vidensk. Selsk. Mat.-Fys. Medd. 23, 1 (1945).
  * (8) C. W. De Jager, H. De Vries, and C. De Vries, Atom. Data Nucl. Data 14, 479 (1974).
  * (9) H. De Vries, C. W. De Jager, and C. De Vries, Atom. Data Nucl. Data 36, 495 (1987).
  * (10) Ch. Elster, J. H. Thomas, and W. Glockle, arXiv:9708017v1 [nucl-th], 1997\.
  * (11) I. Fachruddin, Ch. Elster, and W. Glockle, Phys. Rev. C 62, 044002 (2000).
  * (12) M. Rodriguez-Gallardo et al., Phys. Rev. C 78, 034602 (2008).
  * (13) S. Veerasamy, Ch. Elster, and W. N. Polyzou, Few Body Systems 54, 2207 (2013).

Figure 1: Elastic differential cross sections for 4He + 56Fe, 4He + 20Ne, 4He
+ 12C, and 4He + 4He reactions at a lab projectile energy of 1 GeV/n. NR
results are indicated with solid red lines, and REL results are given as
dashed blue lines.

Figure 2: Elastic differential cross sections for 20Ne + 20Ne reactions for
projectile lab kinetic energies of 150, 500, 1000, 20000 MeV/n. Eik.
represents eikonal, LS3D represents three-dimensional Lippmann-Schwinger, and
PW represents partial wave. Non-relativistic results are denoted (NR) and
relativistic results are denoted (REL).

Figure 3: Elastic differential cross sections for 56Fe + 56Fe reactions for
projectile lab kinetic energies of 150, 500, 1000, 20000 MeV/n. Eik.
represents eikonal, LS3D represents three-dimensional Lippmann-Schwinger, and
PW represents partial wave. Non-relativistic results are denoted (NR) and
relativistic results are denoted (REL).


# DC: Depth Control on Quantum Classical Circuit

1st Movahhed Sadeghi  Pennsylvania State University
CSE Conference
<EMAIL_ADDRESS>2nd Soheil Khadirsharbiyani  Pennsylvania State University
CSE Conference
<EMAIL_ADDRESS>3rd Mostafa Eghbali Zarch  NC State University
ECE Conference
<EMAIL_ADDRESS>4th Mahmut Taylan Kandemir  Pennsylvania State University
CSE Conference
<EMAIL_ADDRESS>
###### Abstract

As the application range of Near-term Intermediate-scale Quantum (NISQ)
systems expands, the primary hurdle that emerges is the assurance of circuit
reliability. Various facets of quantum computing, from circuit design to
multi-qubit mapping strategies, have aimed at bolstering reliability through
assorted optimizations. Quantum classical circuits, a key type of quantum
circuits, have been previously studied with the aim of enhancing reliability
by reusing ancilla-qubits and employing a variety of strategies to optimize
the size and depth of the circuit. However, even the most sophisticated
optimization strategies may not yield reliable results for large-scale
circuits.

Classical Quantum Circuit Depth Control (DC), proposed and evaluated in this
paper, seeks to confront this critical issue. The DC approach breaks a given
classical circuit into segments, and limits its depth, thereby ensuring
reliable output and reduced mapping costs for real quantum hardware. In
addition, DC can deliver reliable output for quantum classical circuits of any
depth on any NISQ system. Our trials with DC indicate that it consistently
renders reliable output for quantum classical circuits that previously showed
minimal or no reliability in output. Importantly, DC ensures the attainment of
the expected output with a Probability of Successful Trial (PST) greater than
50% for baseline circuits that otherwise yield no reliable output. DC
achieves, on average, an 11x PST improvement compared to the non-segmented
baseline, while guaranteeing the correct output with a significant lead over
the second most common result. Furthermore, by reducing the number of gates
per segment under DC, all mapping/routing optimizations can be completed in
polynomial time, as confirmed by our theoretical analysis. This accomplishment
was previously out of reach with mapping/routing techniques, which required
exponential time.

##  I Introduction

Over the past few decades, quantum computing has witnessed significant
advancements, driven by factors such as superior speedup compared to classical
systems in algorithms, as shown in ‘[1, 2, 3, 4, 5], as well as increased
availability of quantum hardware, as evidenced by commercial quantum products.
In fact, major vendors, including Google, IBM and Amazon, have developed
quantum machines to exploit the promising potential of quantum algorithms.
However, due to limitations such as restricted number of qubits and
significant errors from various sources, quantum systems are currently unable
to reach their full-potential. Furthermore, proposed error correction methods
for quantum systems, such as [6, 7, 8, 9], have been unable to address these
errors, due to the excessive number of qubits required to implement them.

To tackle this issue, Noisy Intermediate-Scale Quantum (NISQ) systems have
been introduced, aiming to execute small-to-medium circuits on quantum
machines, without relying on error correction techniques. Although this
approach offers researchers a way to optimize quantum programs, error rates
remain high even for such relatively small circuits. Consequently, recent
works have focused on enhancing reliability by minimizing the impact of errors
through mapping [10, 11, 12, 13, 14, 15], scheduling [16], routing [13, 14,
12], and other optimizations. These techniques have shown relatively reliable
outputs when circuit depth is not very high.

Quantum computation is capable of performing all ’classical computations’
while also providing enhanced algorithmic performance opportunities [1, 2, 3,
4, 5]. As classical computation has well-known algorithms and is important for
the sake of backward compatibility, it is desirable to implement classical
logic and computations on quantum computers. This leads to the development of
Quantum Classical Circuits, which are basically classical circuits implemented
using quantum gates on qubits. Reversibility is an additional advantage of
these circuits over their classical counterparts. For example, the input of a
quantum classical AND gate can be uniquely specified from its output, whereas
the conventional classical AND gate does not offer this feature (i.e., it is
impossible to uniquely determine the inputs of an AND gate whose output is 0
in the classical domain). This has led to significant interest in optimizing
these circuits aggressively [17, 18, 19]. Other applications for these gates
include sub-gates in general quantum algorithms/circuits [1, 2], as well as
research in analyzing classical logic under quantum state initialization [18].

While small quantum classical circuits yield reasonably accurate results,
reliability decreases as the number of gates and the depth increase. Motivated
by this observation, in this paper, we propose a novel approach to address
these challenges, enabling the execution of ’infinitely large’ quantum
classical circuits with ’improved reliability’ on NISQ systems. Our motivation
arises from the observation that, as quantum systems scale, the reliability of
the outputs generated by large quantum circuits declines substantially due to
various errors, such as gate errors and coherence errors. Drawing inspiration
from classical computing, where dynamic random-access memory (DRAM) cells use
a ’retention time’ based mechanism to retain stored data and avoid leakage
errors, we attempt to slice a given large circuit and obtain highly reliable
results by manipulating classical memory for each ’block’ and preventing the
errors from continuing from one block to the next. This approach can be
advantageous if we can ensure the reliability of each block’s results, leading
us essentially to develop a simple, effective, and universally applicable
’noise filtering mechanism’ for quantum circuits, enabling in a sense infinite
growth in circuit gate counts or depth while maintaining output reliability.

In this paper, we present a pioneering approach to address the challenge of
error accumulation in quantum circuits, which often results in ’unreliable
outcome/result’. Our method, called Quantum Classical Circuit Depth Control
(DC), focuses on quantum classical circuits; divides such circuits into
’blocks’; and corrects the states of qubits at the end of each block,
eventually stopping the errors from propagating over the circuit.
Specifically, we introduce two strategies for this purpose: Static-Depth-
Control (SDC) and Dynamic-Depth-Control (DDC), both designed to ensure a high
probability of obtaining accurate outputs while offering different tradeoffs
in terms of reliability and job execution time. Additionally, we tackle the
issue of ’reversibility’ in quantum circuits after applying our DC approach.
We demonstrate that a certain level of reversibility can be maintained, which
is important as it can aid in error correction and reliability checks. Hence,
our proposed DC provides a promising solution to enhance the reliability and
performance of quantum classical circuits in the era of NISQ systems. In
summary, this paper makes the following key contributions:

  * $\bullet$

We introduce, implement, and evaluate DC (Quantum Classical Circuit Depth
Control), an approach that can effectively limit errors ($\epsilon_{n}$) in
quantum classical circuits and enable the execution of infinitely large
circuits.

  * $\bullet$

We develop two implementation strategies for achieving DC, namely, Static-
Depth-Control (SDC) and Dynamic-Depth-Control (DDC).

  * $\bullet$

We demonstrate that DC not only ensures the reliability of the output but also
produces super-linear speedups for mapping, routing, and other transpile 111In
Qiskit [20], ’transpiling’ is the process of converting a high-level quantum
circuit into a low-level circuit optimized for a particular quantum hardware
architecture. optimizations. In general, our SDC approach achieves a speedup
from $\mathcal{O}(m!n!)$ to $\mathcal{O}(n)$, on mapping/routing algorithm.

  * $\bullet$

Additionally, we introduce a general ’uncomputation’ strategy for quantum
classical circuits after applying DC. Specifically, by adding a ’reverse DC
algorithm’, we demonstrate that, despite using a measurement gate in the
middle of the circuit, we still preserve circuit’s reversibility.

  * $\bullet$

Consistent with our theoretical analysis, DC effectively delivers reliable
output on real quantum hardware for circuits that initially exhibit little to
no reliability. More specifically, our results reveal an 11x PST improvement
compared to ’non-blocked’ execution, while ensuring the correct output is
achieved with a substantial gap relative to the second most reported result –
a feat that the baseline could not achieve.

##  II Background

This section first provides an overview of quantum computing, quantum systems,
quantum errors, and methods for mitigating them. Next, it discusses ’quantum
classical circuits’ and their construction.

###  II-A Quantum Computation

Quantum computing operates based on ’qubits’, as opposed to classical ’bits’.
In classical computation, bits are represented by a value of $0$ or $1$,
whereas qubits are represented by a vector specified as
$|\phi\rangle=\alpha|0\rangle+\beta|1\rangle$. Upon measurement, a qubit will
yield $0$ or $1$ with probabilities $\alpha^{2}$ and $\beta^{2}$,
respectively, given the constraint that $\alpha^{2}+\beta^{2}=1$. When a new
qubit is added, the state space expands exponentially (e.g., a two-qubit
system will be
$\alpha_{00}|00\rangle+\alpha_{01}|01\rangle+\alpha_{10}|10\rangle+\alpha_{11}|11\rangle$),
which can be advantageous for certain applications or algorithms. Indeed, the
potential for quantum computing presents fascinating possibilities, with
various performance benefits compared to their classical counterparts. In some
cases, the magnitude of these improvements can reach exponential levels
compared to the classical algorithms, as demonstrated by, for example, Shor’s
algorithm [1].

Numerous algorithms have been introduced over the past few decades to
demonstrate the enhancements offered by quantum computing. For instance,
Shor’s algorithm [1] was developed to shift the order of discovering prime
factors from classical ’exponential time’ to quantum ’polynomial time’,
whereas Grover’s search algorithm [2] provides a square-root improvement
compared to its classical counterparts. Other significant quantum algorithms
include Quantum Approximate Optimization Algorithm (QAOA) [3], methods for
identifying potential chemical links [4], and machine learning (ML) algorithms
[5].

###  II-B Noisy Intermediate Scale Quantum Computation Systems (NISQ)

Figure 1: (a) SWAP gate implementation, (b) Architecture of the system, (c)
Pre-mapping circuit, and (d) Post mapping circuit.

Due to the potential benefits offered by the aforementioned quantum
algorithms, several vendors, including IBM, Google, and Intel, are developing
quantum hardware solutions. However, to our knowledge, all existing qubit
implementation technologies available today are susceptible to ’errors’, and
current quantum error correction (QEC) codes require, unfortunately, an
impractical number of ’parity’ qubits, leading to the emergence of the NISQ
(Noisy Intermediate Scale Quantum) era. NISQ systems are based on two
fundamental principles: i) any quantum logic can be achieved by combining
unitary gates with CNOT gates, and ii) a system with a limited number of
links, multi-qubit operations can still be executed via SWAP gates. Quantum
operations supported by quantum machines can be divided into two broad groups.
The first group includes unitary gates, which modify either the ’phase’,
’value’, or both phase and value of a qubit, effectively altering the ’state’
of a qubit. Examples of such gates are X gate, Z gate, Y gate, and rotating
gates. The second group consists of two-qubit gates, e.g., the CNOT gate,
which is used to entangle two qubits, causing them to establish a so called
’shared’ state. By utilizing three CNOT gates, a SWAP gate can be constructed,
which can be used to swap the states of two qubits.

To illustrate how a NISQ system operates, Figure 1(a) presents a SWAP gate
implementation, and Figure 1(b) demonstrates the execution of a sample quantum
circuit on a basic NISQ. Using the mechanism depicted in Figure 1, a NISQ can
execute any quantum logic as long as it encompasses a full set of unitary
operations along with a CNOT, irrespective of the number of connections it
possesses. It is important to note that NISQ systems are designed and
optimized for ’small-to-medium’ sized quantum circuits, and due to their
error-prone and noisy nature, they inevitably fail when targeting ’large
circuits’.

###  II-C Quantum Errors

Quantum errors in a NISQ system arise from the imperfect physical nature of
the underlying system. There are three fundamental types of quantum errors
that can occur during the execution of a quantum circuit:

  * $\bullet$

Gate Error: This error results from the imperfect implementation of quantum
gates and system noise. Since a ’measurement gate’ is also a quantum gate, it
can be included in this error type.

  * $\bullet$

Coherence Error: When a qubit remains idle, its state approaches $|0\rangle$
exponentially over time with respect to two constant terms, named $T_{1}$ and
$T_{2}$. $T_{1}$ is the constant reflecting the transition from state
$|1\rangle$ to state $|0\rangle$, and $T_{2}$ represents the transition from
state $|+\rangle$ to state $|0\rangle$. The larger $T_{1}$/$T_{2}$, the
smaller the exponent, and consequently, the lower the coherence error.

  * $\bullet$

Crosstalk Error: When two gate operations occur simultaneously on adjacent
qubits, there is a probability that their states would flip. This can be more
problematic when both operations involve ’entangled’ gates, such as a CNOT
gate.

These errors are one of the primary concerns when executing quantum circuits
on real quantum hardware. Various mapping, circuit design, gate scheduling,
and QEC strategies (e.g., see [6, 7, 8, 9] and the references therein) have
been developed to mitigate these errors and achieve reliable output from a
quantum circuit.

###  II-D Quantum Classical Circuits

Quantum classical circuits are a collection of classical circuits implemented
using quantum operations and qubits. The primary reason for implementing
quantum classical circuits is to take advantage of the additional
’computational capacity’ provided by quantum computing. It is important to
note that all classical circuits can be implemented using quantum operations.
To implement a classical circuit on a quantum machine, we need to identify how
a NAND gate can be implemented using quantum operations, as it is well-known
that the NAND gate is sufficient to construct all classical logic. To
demonstrate this, a NAND gate is first divided into an AND gate followed by a
NOT gate. Then, by employing MCT (Multi-Controlled Toffoli) circuits, we can
implement all these circuits, as illustrated in Figure 2.

Figure 2: Implementing (a) Not gate; (b) 2-input AND gate; and (c) 2-input
NAND gate.

The AND operation yields a true output when both inputs are 1 and a false
output otherwise. The Toffoli gate, as depicted in Figure 2(a), performs the
same operation by flipping the target value only when both control qubits are
in the $|1\rangle$ state. As the starting state of the target is $|0\rangle$,
the output is $|1\rangle$ when both control qubits are in the $|1\rangle$
state, which is similar to an AND gate. A quantum X gate flips the value –
amplitude – of its input, converting a $|0\rangle$ state to a $|1\rangle$
state, and vice versa. This operation essentially mimics a classical NOT gate,
as illustrated in Figure 2(b). To construct a NAND gate, it is sufficient to
initialize the target qubit to the $|1\rangle$ state, as illustrated in Figure
2(c). As a result, we obtain a NAND gate by employing an AND plus NOT gate
set, which is a complete classical gate set, enabling us to represent
basically ’all classical logic’ using ’quantum logic’.

Quantum classical circuits are typically constructed using various $n$-qubit
controlled Toffoli gates (MCT). While there also exist alternative methods for
creating these circuits, they tend to be less generic or less straightforward
than the Toffoli gate-based approach, and as such, they often constitute
specially-designed quantum classical circuits. There are the three major ’use-
cases’ for quantum classical circuits:

  * $\bullet$

One reason to prefer quantum computers that support ’classical logic’ (e.g.,
adders, multipliers, etc) is to ensure backward compatibility with existing
classical computational systems and algorithms.

  * $\bullet$

Another motivation for constructing quantum classical circuits is to study how
classical circuits behave when interacting with quantum states. Generally
speaking, when optimizing quantum classical circuits, they are treated as
’generic’ quantum circuits from a hardware standpoint, rather than being
specifically identified as quantum classical circuits.

  * $\bullet$

Quantum classical circuits can be utilized to perform classical operations
even as part of quantum circuits. Shor’s algorithm [1] and Grover’s algorithm
[2] are two examples that accommodate classical ’sub-circuits’.

It is important to note that quantum classical circuits have been previously
researched as part of a large body of works. In fact, prior works such as [19,
18, 17] represent only a small subset of many previously-published studies
that have utilized quantum classical circuits in various domains and settings.

##  III Related Work

In this section, we go over recent advancements aimed at improving the output
reliability of quantum circuits. We begin by examining circuit-level
optimization techniques and then proceed to discuss error minimization
oriented approaches.

###  III-A Classical Circuit Optimizations

The ’size’ (’width’ formally) of a quantum circuit is the number of qubits it
has, and the ’depth’ of the circuit is the number of quantum circuit DAG
levels (serial gates). For example, the size and depth of the quantum circuit
depicted in Figure 1 is, respectively, $3$ and $7$. Reducing the size and/or
depth of a quantum circuit is important because of at least two reasons:

  * $\bullet$

Improving Reliability: As stated in Section II-B, the NISQ system is primarily
intended to provide reliable outputs for small-to-medium sized quantum
circuits.

  * $\bullet$

Coping with Limited Resources: Qubits are limited and valuable resources, and
infinitely large quantum systems are not currently attainable. Furthermore, we
currently do not have a ’quantum memory’ to compensate and create the illusion
of an infinitely large system, as is the case with classical computers.

While the first reason is the primary and predominate concern – and the main
focus of our paper – there exist interesting approaches that target the second
reason as well [21, 22, 23].

Quantum classical circuits can be constructed using numerous MCT gates, but
the problem is that the classical gate sets of most NISQ systems contain only
the X gate, CNOT gate, and Toffoli gate. To construct these various controls
from the existing physical gates, we must incorporate ’ancilla-qubits’, as
illustrated in Fig. 3 (other reasons for ancilla-qubits in a circuit include
achieving circuit reversibility and implementing parity qubits for error
correction). Reusing these ancilla-qubits improves the reliability of quantum
circuits by optimizing their size and depth. Paler et al. [19] employ
measurement gates to reduce the size of a quantum classical circuit via
’ancilla-qubit reuse’. In comparison, Parent et al. [17] utilize
’uncomputation’ (the process of cleaning up the ’temporary effects’ on ancilla
bits so that they can be reused) to reuse ancilla-qubits and reduce circuit
size, thereby preserving the ’reversibility’ of the circuit. Their work
introduces two policies – ’eagerly’ uncompute after use or ’lazily’ uncompute
at the completion, with the former leading to smaller size with greater depth
and the latter to larger size with reduced depth. Finally, SQUARE [18]
attempts to optimize circuit depth and size by focusing on the physical system
architecture and selecting the most suitable uncomputation policies for a
particular ancillary-qubit to produce a quantum classical circuit that is
size- and depth-optimized.

Figure 3: Implementing a 3-controlled MCT gate via Toffoli gates.

In addition to quantum classical circuit optimizations, three recent
concurrent works [21, 22, 23] attempt to reduce the ’size’ (’width’) of
quantum circuits by employing ’middle measurement’ and ’middle reset’ gates
(they can be applied to quantum classical circuit as well). When applicable,
such circuit size reduction strategies can generate promising improvements as
far as output reliability is concerned. These gains in reliability are
consistent with our intuition that a smaller size and/or depth in a quantum
circuit results in greater reliability in NISQ systems. Note however that,
while such works try to reduce the ’size’ of a given quantum circuit, our
proposed approach in this paper aims at reducing the ’depth’ of the circuit;
so, these two lines of approaches are complementary.

###  III-B Error Optimizations

There exist various techniques for reducing each of the three categories of
errors described in Section II-C, in order to increase output reliability. The
two most important techniques for reducing coherence errors are ’gate
scheduling’ and ’dynamic decoupling’ (DD). Scheduling gates can be used to
optimize the tradeoff between coherence errors and crosstalk errors [16], and
in particular gates can be positioned to decrease coherence errors [24]. On
the other hand, DD is the primary approach employed for combating coherence
errors. Pulse control that reduces the qubit’s frequency to increase T1/T2 and
gate string repetitions [25, 24] – such as XY, X,… – with a delay in between
to frequently reduce the t variable in the exponent are the two main
incarnations of DD.

Crosstalk and gate errors can be addressed to some extent via ’logical-to-
physical’ qubit mapping as well as ’gate cancellation’ [26, 10]. SWAP gates
increase, in the absence of a link, the circuit depth; therefore, mapping
techniques attempt to reduce the number of SWAP gates to be added to the
circuit [10, 11, 12, 13, 14, 15], which in turn reduces gate errors and
potential coherence errors. In comparison, gate cancellation reduces the
number of gates and can offer similar advantages [26, 10]. By carefully
positioning qubits and routing the SWAP operations in directions that avoid
crosstalks, mapping can prevent/reduce crosstalk errors [27, 14].

##  IV Motivation

This section begins with a discussion of our problem definition and the
severity of the problem. It then proposes a solution based on our observations
and the fundamentals of the NISQ systems.

Figure 4: SWAP addition following the circuit-to-architecture mapping for
three different cases.

###  IV-A Reliability of Large Quantum Circuits

As vendors increase the scale of their quantum machines and systems [28], it
becomes more likely that larger quantum circuits will be executed on them.
Accordingly, the reliability of the outputs generated by such circuits
declines to alarming degrees. It is important to note that for obtaining a
reliable output, two criteria must be met: (1) the probability of achieving
the correct output should be the highest, and (2) there should be a
distinguishable difference between the correct output and the second (false)
output. For instance, having the correct output with a 40% probability while
obtaining the second (false) output with a 39% probability does not indicate a
reliable output, as it is difficult to determine which result is accurate.
Among the errors enumerated and discussed in Section II-C, gate errors are the
least problematic ones. In fact, the main idea behind dynamic decoupling (DD)
optimizations [29, 30, 31, 32, 33, 34] is the conversion of coherence errors
to gate errors. For example, assuming a circuit of size 10 qubits with an
average gate count of 40 gates per qubit line – a total of 400 gates after
transcompile – on a system with an average gate error rate of $1\%$, we suffer
an average error rate of nearly $40\%$ due to gate errors alone. Per the SABRE
[35] mapping and routing policy, which is a commercially-available optimized
qubit mapping and routing policy, the execution of a Multiplier_n25 [36] (a
25-qubit circuit) circuit on the Ibmq-montreal [28] machine resulted in a PST
222PST, or Probability of successful Trial, is the ’fraction’ of the number of
correctly measured outputs within all measured outputs. of less than $2\%$
which is practically ’noise’, not an ’output’!

Let us now illustrate the issue with a similar problem and its solution in a
classical computer. It is well-known that a DRAM cell can store data for a
limited time before the capacitors discharge and the data gets erased (due to
leakage). To prevent this potential data loss in DRAM, we need a mechanism
that modifies the DRAM cell before this threshold is reached. Now, we can
apply any read/write optimization policy to the cells, but one eventually
faces an insurmountable obstacle – program access patterns. Eventually, the
solution would be determining ’retention times’ of different DRAM rows and
refreshing the rows’ stored values to retain them and hence avoid leakage
error. This approach is straightforward, yet effective. Note that, producing
reliable results from large quantum circuits presents a similar challenge
here. The NISQ systems are inherently noisy, and regardless of the
optimizations we employ to increase their output reliability, we will
ultimately reach a ’wall’. To enable circuit size/depth to grow infinitely, we
need a mechanism analogous to the DRAM retention time, like, for example, a
’qubit retention time’ mechanism or, more accurately, a ’noise filtering
mechanism’. Similar to the DRAM retention time, such a mechanism targeting
quantum circuits should be simple, effective, and universally applicable.

###  IV-B Mapping and Algorithm Complexity

Numerous mapping [10, 11, 12, 13, 14, 15, 27] and gate scheduling [16] methods
have been proposed for NISQ systems over the past decade, aiming to optimize
circuits for the underlying hardware. The main driving force behind these
techniques is the recognition that each qubit possesses unique characteristics
(such as coherence error and number of connections), and to achieve the most
accurate results, these methods must utilize the most reliable qubits while
minimizing CNOTs and coherence errors. Mapping techniques often involve
significant graph processing, with complexities reaching up to factorial
levels [13, 10]. As a result, as the circuit’s width/depth increases, the
algorithm complexity and execution time grow exponentially. This observation
is also confirmed by [13], which states that qubit mapping is an NP-complete
problem. Consequently, obtaining the most optimal mapping is not always
feasible for large circuits or systems, and mapping techniques typically
settle for suboptimal mappings.

Furthermore, conventional mapping algorithms and gate scheduling approaches
demand resource-intensive ’error profiling’ for physical qubits and their
interconnections. This process requires ’system calibrations’ from vendors on
a daily basis to generate relevant statistics, rendering the device under test
virtually inoperable during those periods [28, 16]. Employing ’small’ quantum
circuits not only circumvents the NP-complete algorithm input size, yielding
super-linear performance gains, but also enables the production of ’verifiably
reliable’ outputs without necessitating mapping optimizations or error
profiling.

Figures 4(a) and (b) depict circuits that can be mapped to the underlying
quantum system without necessitating any additional SWAP operations. In
contrast, Figure 4(c) demonstrates a circuit that indeed requires a SWAP
operation, even though it is formed by simply merging the circuits in parts
(a) and (b) together. That is, while the small circuits in parts (a) and (b)
individually do not require any SWAP operation, a straightforward combination
of them in part (c), which is relatively larger than (a) and (b), does. Hence,
this example illustrates that by running smaller circuits, the output
reliability can be enhanced, aligning well with the objective of this paper.
This observation about NISQ systems can be generalized:

> The smaller the quantum circuit, the less likely it is that additional SWAPS
> would be introduced; consequently, we would experience better execution
> time, lower cost, and improved output reliability.

The technical details of our proposed design are given later in Section V.

Figure 5: (a) An infinitely-deep quantum classical circuit; (b) A microscopic
look at the stages of the circuit. Adding only measurement gate with no noise
filtering mechanism; and (c) The modified circuit with noise filtered.

###  IV-C Motivation Summary

To recap, the goal of this study is to develop a method to satisfy the
following:

  * $\bullet$

First and foremost, we would like to develop a simple yet effective universal
method, specifically for quantum classical circuits where a supportive
technology, namely, classical memory, already exists. This method also
provides insights for quantum circuits in general when quantum memory becomes
available. Our proposed approach – circuit depth control – enables us to
infinitely increase the size/depth of circuits while maintaining the
reliability of the results on a NISQ system.

  * $\bullet$

Secondly, we intend to make it possible for more optimized mapping algorithms
to be applied to the target circuits by obtaining ’super-linear’ speedups by
reducing the input sizes of the NP-complete mapping algorithms.

  * $\bullet$

Thirdly, we want our method to be as ’fail-safe’ as possible, so that we have
’confidence’ in the reliability of any large circuit even without mapping, or
gate scheduling, or any other optimization, thereby eliminating the need for
(costly) ’system calibrations’ from vendors.

  * $\bullet$

Lastly, we intend to identify potential opportunities for existing mapping
algorithms to reduce the number of SWAPs in the final executable circuit,
thereby reducing circuit execution latency and lowering the incurred costs.

##  V Design and Implementation

In this section, we first outline the observations that form the basis of our
proposed design. Next, we provide a detailed description of the design and
justify it based on the stated observations. Following that, we address a
potential issue that may arise from the proposed strategy and offer a solution
for it. Lastly, we assess our two proposed strategies and discuss their
applicability and effectiveness.

###  V-A Heuristic and Overall Goal

First, let us identify the root cause of the problem. Figure 5(a) illustrates
a typical quantum circuit of medium size with an unknown depth and number of
gates. The errors at the end of each stage are represented by
$E_{0}=\epsilon_{0}$ to $E_{n}=\epsilon_{0}+\epsilon_{1}+...+\epsilon_{n}$. It
is clear that $E_{n}=\epsilon_{0}+\epsilon_{1}+...+\epsilon_{n}$ is greater
than $E_{n}-1=\epsilon_{0}+\epsilon_{1}+...+\epsilon_{n}-1$, and $E_{1}$ is
greater than $E_{0}=\epsilon_{0}$, as errors accumulate and increase with the
addition of each gate or stage. Moreover, noise does not decrease with the
addition of a gate, as negative noise does not exist in nature. As the number
of gates increases, we observe that $E_{n}\geq 50\%$ reaches a point where
noise simply becomes dominant, leading to practically ’unreliable’ results.

Figure 5(b) provides a close-up view of the circuit shown in Figure 5(a). If
we can eliminate errors and purify the states at the end of ’each block’ (as
indicated by the arrows in Figure 5), by correcting their states and storing
them in a memory, we can ensure a certain level of ’reliability’ at the end of
the entire circuit. However, this approach would necessitate the use of a
’quantum memory’, which is currently not available. On the other hand, we do
have ’classical memory’ that can work in tandem with quantum systems, allowing
us to potentially handle ’quantum classical circuits’, if not the generic
quantum circuits. Consequently, our focus will be on ’quantum classical
circuits’, as we aim to address the problem within this context.

The goal here is to correct the states of the qubits at the end of each block
shown in Figure 5(b). Since it is a quantum classical circuit, the state of
each qubit in a perfect, noiseless system should be either $|0\rangle$ or
$|1\rangle$. However, due to noise, the state of each qubit at the end of a
block is either $(1-\epsilon)|0\rangle+\epsilon|1\rangle$ or
$(1-\epsilon)|1\rangle+\epsilon|0\rangle$, deviating from the ideal
$|0\rangle$ or $|1\rangle$ states. By performing a measurement, these quantum
states will be collapsed and recorded as either $0$ or $1$, based on their
expected values. Consequently, the states are restored, allowing us to proceed
to the next stage. While, at first look, it seems, by merely applying a
measurement gate (Fig. 5 (b)), the classical state would recover
automatically, in reality doing so would just add a ’gate measurement noise’
into the existing noise. For instance, consider a situation where, after
applying a measurement gate to an expected $0$ value, the noisy state
converges to $0$ (with a probability of $1-\epsilon$), and $1$ (with a
probability of $(\epsilon)$). After the measurement, we would get
$(\epsilon+\epsilon_{m})\times{n}$ measured values of $1$ – $n$ being the
number of iterations/shots 333A ”shot” refers to a single execution of a
quantum circuit on a quantum processor, allowing for the collection of
measurement results and the exploration of probabilistic outcomes. of circuit
execution – and $(1-(\epsilon+\epsilon_{m}))\times{n}$ measured values of $0$
solidify the ’noise error’ and introduce ’measurement noise’ into the original
circuit. Therefore, simply applying a measurement gate alone (similar to DRAM
retention time) will not rectify the state, and will instead simply increase
the error from $\epsilon$ to $\epsilon+\epsilon_{m}$.

Since using the measurement gate alone is not sufficient to achieve our
desired goal, we need to incorporate a mechanism to filter out noise and
purify the results at the end of each block. As illustrated in Fig. 5(c), if
$\epsilon_{i}$ at the end of each block is small enough, we can reasonably
assume that the correct output would be stored with the highest counts. To
ensure that $E_{i}$ is small enough, it is necessary to ascertain that the
blocks are ’small enough’, such that the probability of obtaining an incorrect
result is minimal. By selecting a ’reliable small block’, we can confirm that
the correct output is measured with the highest probability, which we will
then use as ’input’ for the following block. In other words, if the output
with the highest count at the end of the $(i_{th})$ block is the
$(001110101...)$ stream, then the input for the $(i_{th}+1)$ block is the
$(--xxx-x-x...)$ gates. As a result, the errors at the end of each block are
eliminated, and the final (result) error is limited by the error of the last
block, as opposed to the accumulation of the errors from all the blocks.
Therefore, we reach the following important conclusion:

> If all blocks are ’sufficiently small’, the quantum classical circuit can be
> infinitely large (in depth, not size, as size/width is constrained by the
> number of qubits in the system) with a bounded error equal to the error of
> the last block $(\epsilon_{n})$ on any NISQ system.

Our main objective is to determine the block size that enables us achieve our
goal of limiting error propagation for an infinitely-large circuit.
Furthermore, we aim to facilitate more mapping optimizations by creating
blocks before transpiling, allowing the transpiler to use any level of
optimizations for the smaller sub-circuits. It is important to note that this
block creation could be performed after transpiling, but this comes at the
cost of losing mapping optimizations, a mentioned in Section IV-B. In the
evaluation section, we explain why it is not recommended to forgo existing
optimizations and rely solely on DC. Our proposed DC can be implemented in two
different ways – static depth control and dynamic depth control – which are
discussed next.

###  V-B Static Depth Control (SDC)

In this section, we introduce our first approach, Static-Depth-Control (SDC),
keeping two primary objectives in mind: i) guaranteed reliability of each
block, and ii) simplicity and applicability of the algorithm.

In the Static-Depth-Control (SDC) approach, our goal is to create ’uniformly-
sized’ blocks with a high probability of obtaining the correct outputs.
Ensuring the accuracy of the outputs is of utmost importance, as the objective
is to filter out the ’noise’ to get the ’correct output’. In other words, if
an error occurs in the initial or intermediate layers, it can propagate to the
end of the circuit, leading to an incorrect result being reported with high
confidence and counts. Now, we need to identify the ’block creation criteria’
that can ensure minimum error on the sliced circuits. We consider two primary
block creation strategies for our circuits: i) block creation based on the
number of gates from the circuit: this approach creates blocks of the circuit
in a way that ensures a similar number of gates in different blocks; and ii)
block creation based on the number of layers in the directed acyclic graph
(DAG): this approach creates blocks of the circuit such that each block has a
similar number of DAG layers.

Although block creation based on the number of layers in the DAG appears
promising, this approach is clearly circuit-dependent and may result in one
block containing multiple high-error gates while others do not. As a result,
we opt for block creation based on the gate count, as it offers greater
reliability and leads to a more even distribution of blocks. Further, as the
system grows larger, there are fewer and fewer links between qubits [28]. For
example, IBM’s largest advertised system has 433 qubits, so a system with 400
qubits could hypothetically have a DAG layer with 100 CNOT operations (each
CNOT is on 2 qubits $2\times 100=200$ can feat easily in 300 qubits to execute
in parallel). Even if we create blocks on the premise of a single DAG layer,
the number of potential SWAPs – due to low links and number of CNOT gates –
and the possibility of crosstalks would render the output unreliable.
Therefore, we believe that the safest and more balanced method would be block
creation based on gate counts.

1 Input: $Circuit$ $n\>\longrightarrow$ number of gates in circuit
$R_{Threshold}\>\longrightarrow\>$ the minimum acceptable fidelity of
$circuit[i]$ block Register: $Fidelity=0$ $Result=null$ Output:
$Final\\_Resaults$ Algorithm: $Circuit[0]=Circuit$ for  _i in range(n)_ do

$Circuit[i]\longleftarrow Circuit.break(\frac{n}{i+1})$ ;

// grab the first $\frac{n}{i+1}$ gates in the circuit

$Fidelity=Circuit[i].fidelity()$ ;

// calculate the fidelity of circuit

2 if  _( $Fidelity\>\geq\>R_{Threshold}$)_ then

3 $Result=Circuit[i].measure()$ for  _i,yes in
enumerate(reversed(Max(Result))_ do

4 if  _yes == ’1’_ then

5 Circuit.x(i)

6

;

// for 1s in key with max count we add an X gate as initialization for the
circuit remnants

$Circuit=Circuit-circuit[i]$ ;

// attach the remnant of the circuit to the initialization

7 if  _$Circuit==null$_ then

8 $Final\\_Resaults=Result$

9

10

Algorithm 1 DDC algorithm.

Now that our block creation criteria has been decided, we can proceed to
explain the details of our Static-Depth-Control (SDC) strategy. We define a
constant ’block size’, based primarily on the desired system attributes. This
size must be small enough to ensure that we can confidently obtain the correct
output, regardless of the executed circuit. Theoretically, this dimension
could be as small as a single gate, the smallest meaningful circuit
conceivable, if the system is highly noisy and generally unreliable. Clearly,
a system that fails to produce the correct output even for a single-gate
circuit is neither dependable nor practical. The SDC strategy can be described
as follows:

Figure 6: Illustration of the ’reversing-procedure’ on the DC generated
circuit.

  * $\bullet$

First, we start by counting the total number of gates. In our approach, we do
not consider a unitary gate (in a quantum classical circuit, an X gate) as
part of the total gate count.

  * $\bullet$

Each of the basic controlled gates that are physically supported by the
underlying hardware counts as ’one gate’ in our total gate count calculation.

  * $\bullet$

Each gate with more than two control signals is counted as $1+2\times(n-2)$,
where $n$ represents the number of control signals in the gate. It is
important to note that implementing these gates using CNOTs or CCNOTs requires
one ancilla qubit, with a computation and an uncomputation gate for each
additional control signal. If the total number of gates generated from this
operation exceeds our gate count ’threshold’ ($d$) – recall that we are
creating block based on gate counts –, we compile it into basic gates and
apply the block creation technique to it as well.

  * $\bullet$

Upon the completion of each block’s execution, the measured output with the
highest number of counts will be used to initialize the subsequent block. This
initialization can be accomplished by applying X gates to each qubit, if the
input is expected to be 1.

  * $\bullet$

Depending on $d$ and the gate count of the circuit, the final block is either
as large as $d$ or smaller.

To recap, our SDC method is characterized by its low algorithmic complexity.
However, it may result in a substantial number of ’sub-circuits’ (or ’jobs’),
which will be further discussed in Section V-E.

####  V-B1 SDC effect on mapping optimizations

Recall that one of our objectives was to facilitate optimizations on the
complexity of advanced mapping/routing algorithms for all quantum-classical
circuits. In this section, we discuss the impact of DC on the complexity of
these algorithms. The worst-case timing for a mapping and routing algorithm on
a circuit with $n$ active qubits 444Active qubits are qubits with at least one
assigned gate on them (usually control signal gates) and $m$ gates that
consider all the different combinations is equal to $O(m!n!)$ [13]. Using our
algorithm, instead of mapping and routing a single circuit containing $n$
qubits with $m$ gates, we need to perform the mapping/routing
$\left\lceil\frac{n}{d}\right\rceil$ times (number of blocks). In each
mapping, DC has at most $d$ gates (block size of the SDC), and the number of
active qubits in each circuit is equal to $3d$ since each gate in our
technique can have at most two control signals (CCNOT) and the highest number
of active qubits they can use is equal to $3d$. Therefore, the worst-case
timing complexity for each mapping would be equal to $O((3d)!d!)$, which
results in an overall complexity of our algorithm equal to
$O(\left\lceil\frac{n}{d}\right\rceil\times{((3d)!d!)}$. Since $d$ is constant
in our algorithm, the worst-case timing complexity of our algorithm will be
equal to $O\left\lceil\frac{n}{d}\right\rceil\times((3d)!d!)=O(kn)=O(n)$.
Thus, while the original mapping algorithm has a worst-case execution time of
$O(m!n!)$, DC can reduce it to $O(n)$.

###  V-C Dynamic Depth Control (DDC)

In an attempt to decrease the number of jobs generated by the sliced circuit,
we can enlarge the size of each block, accepting a higher level of output
’reliability risk’. Given that the job queue operates on a Longest Job First
(LJF) policy [37], employing a more intricate algorithm may help reduce
waiting time while sacrificing some reliability. It is important to note that
the circuits targeted in this study are initially large enough to yield
unreliable outputs, making this tradeoff reasonable. To that end, we propose
Dynamic-Depth-Control (DDC), which is essentially a ’divide-and-conquer’
approach, designed to establish the appropriate block sizes.

We want to emphasize that, unlike the SDC method, the DDC approach allows for
’varying’ block sizes, based on the gate operations within each block.
Although DDC generally takes longer to generate its circuit, the resulting
circuit is expected to produce its output faster. Both DAG layers and gate
counts can be utilized in the DDC algorithm, with gate counts potentially
providing greater accuracy. For the sake of consistency with the SDC method,
we use ’gate counts’ in our algorithm; however, one may opt, if desired, for
DAG layers (in the DDC approach).

Our DDC divide-and-conquer strategy is presented in Algorithm 1. The process
of transmitting data from one block to another is the same as in the SDC
scheme. The main difference lies in the ’selection of blocks’, which can have
varying sizes as long as they meet the user-defined reliability threshold. In
each iteration, we divide the circuit in half and evaluate the block’s
fidelity. If the fidelity satisfies the threshold, we proceed to use the same
counting standard specified in SDC V-B, initializing the remainder of the
circuit with the output of the previous iteration. If the fidelity is below
the threshold, we continue to halve the block until the ’desired fidelity
level’ is achieved. Calculating the fidelity of a circuit on the target
hardware is a more complex operation compared to using constant-sized blocks
in SDC, but it allows for dynamic block size expansion when possible, reducing
the number of jobs.

It is crucial to maintain a ’sufficiently high’ threshold, as simulations
often overestimate the actual output reliability due to the inability to
accurately account for certain errors like crosstalk. Furthermore, the more
accurate the simulation needs to be, the longer it takes to generate the final
circuit blocks, due to the compilation time. A higher threshold leads to a
lower error rate and a larger number of jobs. Conversely, a lower threshold
would result in fewer jobs at the expense of accepting a higher error risk.

###  V-D Addressing the Reversibility of Quantum Circuits after Applying
HS/DDC

Introducing a measurement gate into a circuit raises valid concerns about the
’reversibility’ of the circuit [19, 18]. Fig. 6 illustrates how our approach
can preserve reversibility between blocks. While each block remains a fully-
reversible quantum classical circuit to which the same uncomputation technique
can be applied, the primary concern lies in the reversibility of the entire
circuit. To achieve uncomputation in a quantum circuit, we need to add inverse
gates in reverse order. Alongside the reverse addition of gates, we must also
execute the DC algorithm in reverse. This would result in both reverse gates
and a measurement gate to be added into the opposite side, serving as input
for the uncomputation logic. Fig. 6 helps to visualize this approach, showing
that a certain level of reversibility can be maintained, with the main change
being the propagation of measurements through the blocks – similar to the DC
propagation, but in the reverse direction. Further optimizations for
uncomputation remain a subject for future work, but as far as this paper is
concerned, the reversibility of the circuit is maintained after applying the
DC method.

###  V-E Discussion

In this section, we compare our previously-proposed DC strategies – DDC and
SDC – which involve manipulating our (classical) memory to limit the errors of
any large (classical) quantum circuit to a limited size circuit block
($\epsilon_{n}$) V-A. Recall that DC is essentially a noise filtration and
value propagation strategy, which can be implemented both statically (SDC) and
dynamically (DDC).

In SDC, circuits are sliced into equal-sized blocks with a chosen number of
gates, as small as desired, to achieve a conservative and reliable result. In
a ’worst-case’ hypothetical system, the block size could be as low as ’one
gate’. The issue with this approach is that the number of jobs (in quantum
machine’s queue) will increase in $O(n)$ complexity, where $n$ is the circuit
depth, and the jobs themselves are small. Consequently, from a queuing latency
perspective, this approach would not be preferable for users. However, from a
reliability standpoint, it is the only method that actually guarantees
reliable output (in the worst-case scenario, with one basic physical control-
gate block size). For vendors, producing output under any input condition is
probably the most desirable option, and they are responsible for the job
policy, allowing them to make modifications while achieving the desired
reliability.

In DDC, the number of jobs is $O(klogn)$ (where $n$ is circuit depth and $k$
is a factor related to system reliability), if the system is sufficiently
reliable and the intended fidelity margin is large. Naturally, as we increase
the fidelity threshold, we get closer to the output produced by the SDC, or we
may not get any output at all (e.g., fidelity = 0.999 on a noisy NISQ). With a
proper threshold (the minimum desired fidelity of a block) however, we would
have larger blocks and fewer tasks, but with a risk to output reliability.
While this approach would be more desirable from a user’s perspective, there
is an associated risk of ’incorrect output’ with the maximum count. Moreover,
the circuit generation with this strategy requires more time compared to the
Static Depth Control, for implementing the DC. Based on i) the noise profiles
of current systems, ii) the similarity levels of simulation outputs to actual
system outputs, and iii) the time required to produce DC (via the DDC
approach) due to simulation hardware requirements and their time consumption,
we currently recommend the SDC approach over the DDC approach. However, this
recommendation may change if/when the simulations become more accurate and
less time/resource demanding.

| Baseline | SDC | DDC-60 | SDC Worst Case
---|---|---|---|---
PST [%] | E-Max(F) | Job# | PST [%] | E-Max(F) | Job# | PST [%] | E-Max(F) | Job# | PST [%] | E-Max(F) | Job#
alu-v2_30_CXonly [38] | 11.6% | 4.6% | 1 | 85.1% | 77.7% | 45 | 36.9% | 24.9% | 9 | 80.2% | 77.3% | 45
C17_204_CXonly [38] | 7.0% | 3.4% | 1 | 51.8% | 39.2% | 41 | 44.6% | 37.9% | 13 | 59.1% | 52.2% | 41
cm82a_208_CXonly [38] | 6.7% | 2.0% | 1 | 83.3% | 79.8% | 57 | 57.4% | 51.5% | 12 | 80.7% | 78.0% | 57
ex2_227_CXonly [38] | 10.7% | 6.6% | 1 | 71.5% | 64.7% | 55 | 56.8% | 51.2% | 11 | 32.0% | 20.2% | 55
Multiplier-n-25 [36] | 2.8% | -8.3% | 1 | 72.5% | 50.3% | 40 | 64.7% | 42.3% | 35 | 0.0% | -72.8% | 40
qft_16_CXonly [38] | 1.0% | 0.6% | 1 | 68.3% | 59.8% | 48 | 68.2% | 57.8% | 10 | 70.7% | 65.2% | 48
Average | 6.6% | 1.5% | 1.0 | 72.1% | 61.9% | 47.7 | 54.7% | 44.3% | 15.0 | 53.8% | 36.7% | 47.7
TABLE I: Experimental results on the ibm_cairo quantum machine [28].

##  VI Experimental Evaluation

This section evaluates DC on Ibm_cairo a 27 qubits Falcon_r5.11 real quantum
hardware [28]. For our evaluations, we choose circuits with sufficient depth
to ensure that the original output reliability is sufficiently low. We then
apply our DC (static DC and dynamic DC) to the target circuits, and report the
output reliability result and the number of jobs, in each case.

###  VI-A Methodology

The setup for our experimental evaluation is as follows. Our quantum classical
circuits are obtained from the QASM benchmark suite [36] and the Revlib
implementation provided by Zhou et. al [38]. The Qiskit transpile’s mapping
and routing policies are set to ’SABRE’ in all our experiments. Each target
circuit in our experimental suite is evaluated on the ibm_cairo [28] machine
that has 27 physical qubits. Five thousand ’shots’ are performed in each case.
The $E-Max(F)$ metric represents the difference between the probability of
obtaining the expected (correct) output and the probability of achieving the
highest false output, expressed as a percentage. When used alongside PST, this
metric helps to gauge the reliability of a system’s output.

The ’worst-case’ results for our SDC strategy are obtained using the Qiskit
transpile ’basic’ routing method and the ’trivial’ layout-method. In this
case, there are no routing and mapping optimization, and the mapping policy is
’direct map’, e.g., it maps logical qubit 0 to physical qubit 0; logical qubit
1 to physical qubit 1; etc. This may cause the block’s gates to map on non-
neighboring qubits unnecessarily, which can be avoided by any optimization
policy. In these experiments, the DDC fidelity threshold is set to 0.6, and
the SDC block size is set to 5 gates. A block size of 5 gates was tested on a
hypothetical worst-case design logic for the system, and it consistently
produced reliable max counts under the ’sabre’ routing and mapping policy.
This range ensured reliable outcomes on the system, regardless of the circuit
executed.

###  VI-B Results

Table I presents the PST and job counts for our two techniques, SDC and DDC,
as well as the baselines. The results show that SDC consistently provides the
most reliable outcomes (higher than 50% PST for the expected output) when the
block size is kept small enough, as discussed in our theoretical analysis in
Section V. In fact, With a block size of 5 (executing 5 gates per job), the
system functions reliably, even in worst-case scenario of using direct mapping
for the majority of cases. Our findings demonstrate up to $\sim{11x}$ PST
improvement (reaching up to 85.1% PST, on average 72.1%) with average
$Avg(E-Max(F))=61.9\%$ providing reliable results when the baseline fails to
deliver reliable output.

While SDC effectively improves PST, it does lead to a substantial number of
jobs executed, resulting in extended queue times for the circuit. As a result,
we prefer to increase the block size and reduce job counts while at the same
time minimizing error impact. It is crucial to note that, if the block size is
not small enough, a false result could become dominant, leading to an error
that propagates through to the final outcome.

In the worst-case scenarios, the direct mapping policy is applied, and block
creation is conducted before transpilation. The results with these scenarios
are presented in Table I. As demonstrated, Multipliern25 [36] fails with no
optimization on circuits as small as 5 gates; this failure occurred in one of
the intermediate stages, so the error propagated to the final stage and led to
an incorrect output with high probability. For example, when a CNOT is present
between q0 and q26 in this scenario, the direct mapping positions them into q0
and q26 on the quantum machine, which are the farthest apart [28],
necessitating a considerable number of SWAPs for correct execution. As a
result, even when block creation is done for 5 gates, a significant number of
gates must be executed post-transpilation due to the added SWAPs. While other
mapping and optimization techniques attempt to place them closer together,
direct mapping processes the circuit without optimization to minimize
transpilation time. Despite these worst-case conditions, the results still
show that, in 5 out of 6 benchmarks, the correct outcome is reported with the
highest PST. To address the error with no other optimization scenario, we
recommend performing block creation after transpilation, ensuring that no
significant number of gates are executed in a single job due to the added
SWAPs. In post-transpile block creation, it is necessary to increase the block
size to account for the additional SWAP operations, which will be included as
part of the total gate count.

Our results also show that Dynamic-Depth-Control (DDC) achieves a 54.7% PST,
while Static-Depth-Control (SDC) reported a higher PST of 72.1%. DDC results
indicate that it can produce reliable outputs $Avg(E-max(F)=44.3\%)$ when the
threshold is adequately high and can concurrently reduce the number of jobs by
approximately 3x. However, SDC demonstrates superiority over DDC due to the
’inconsistencies’ between simulation and real hardware outcomes. For example,
in the simulation of alu-v2_CXonly [38], the reported Probabilistic System
Tolerance (PST) is over 60%, but the actual hardware results show a PST of
just 24%, representing a 2.5x reduction in reliability. Given DDC’s dependence
on simulation, its results might be less dependable compared to SDC.

##  VII Conclusions

In this study, we introduced DC, an approach that ensures reliable results for
quantum classical circuits, regardless of their depth. DC divides a given
quantum classical circuit into smaller, more reliable ’blocks’, filters out
’noise’, and confines the error rate of the quantum classical circuit to that
of its final block. Additionally, DC offers ’super-linear speedups’ for
mapping algorithms, primarily graph processing algorithms with exponential
growth in size or state space, and creates opportunities for highly effective
optimization algorithms by reducing the size of their input circuits. Our
experimental results indicate $\sim{11x}$ PST improvement for 6 benchmarks
through block creation and noise mitigation on a real quantum hardware, while
obtaining the correct output with a distinguishable difference compared to the
second largest output ($41x$ $E-Max(F)$ improvement). Therefore, we believe DC
serves as an inspiration for future work, aiming to enable unlimited depth in
NISQ systems when quantum memory becomes commercially available.

## References

  * [1] Peter W Shor.  Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer.  SIAM review, 41(2):303–332, 1999.
  * [2] Lov K Grover.  A fast quantum mechanical algorithm for database search.  In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing, pages 212–219, 1996.
  * [3] Edward Farhi, Jeffrey Goldstone, and Sam Gutmann.  A quantum approximate optimization algorithm.  arXiv preprint arXiv:1411.4028, 2014.
  * [4] Abhinav Kandala, Antonio Mezzacapo, Kristan Temme, Maika Takita, Markus Brink, Jerry M Chow, and Jay M Gambetta.  Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets.  Nature, 549(7671):242–246, 2017.
  * [5] Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, and Seth Lloyd.  Quantum machine learning.  Nature, 549(7671):195–202, 2017.
  * [6] Austin G Fowler, Matteo Mariantoni, John M Martinis, and Andrew N Cleland.  Surface codes: Towards practical large-scale quantum computation.  Physical Review A, 86(3):032324, 2012.
  * [7] Ling Hu, Yuwei Ma, Weizhou Cai, Xianghao Mu, Yuan Xu, Weiting Wang, Yukai Wu, Haiyan Wang, YP Song, C-L Zou, et al.  Quantum error correction and universal gate set operation on a binomial bosonic logical qubit.  Nature Physics, 15(5):503–508, 2019.
  * [8] Philippe Campagne-Ibarcq, Alec Eickbusch, Steven Touzard, Evan Zalys-Geller, Nicholas E Frattini, Volodymyr V Sivak, Philip Reinhold, Shruti Puri, Shyam Shankar, Robert J Schoelkopf, et al.  Quantum error correction of a qubit encoded in grid states of an oscillator.  Nature, 584(7821):368–372, 2020.
  * [9] Yuwei Ma, Yuan Xu, Xianghao Mu, Weizhou Cai, Ling Hu, Weiting Wang, Xiaoxuan Pan, Haiyan Wang, YP Song, C-L Zou, et al.  Error-transparent operations on a logical qubit protected by quantum error correction.  Nature Physics, 16(8):827–831, 2020.
  * [10] Ji Liu, Peiyi Li, and Huiyang Zhou.  Not all swaps have the same cost: A case for optimization-aware qubit routing.  In 2022 IEEE Symposium on High-Performance Computer Architecture (HPCA). IEEE, 2022.
  * [11] Chi Zhang, Yanhao Chen, Yuwei Jin, Wonsun Ahn, Youtao Zhang, and Eddy Z Zhang.  A depth-aware swap insertion scheme for the qubit mapping problem.  arXiv preprint arXiv:2002.07289, 2020.
  * [12] 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.
  * [13] Swamit S Tannu and Moinuddin Qureshi.  Ensemble of diverse mappings: Improving reliability of quantum computers by orchestrating dissimilar mistakes.  In Proceedings of the 52nd Annual IEEE/ACM International Symposium on Microarchitecture, pages 253–265, 2019.
  * [14] Lei Liu and Xinglei Dou.  Qucloud: A new qubit mapping mechanism for multi-programming quantum computing in cloud environment.  In 2021 IEEE International Symposium on High-Performance Computer Architecture (HPCA), pages 167–178. IEEE, 2021.
  * [15] Xinglei Dou and Lei Liu.  A new qubits mapping mechanism for multi-programming quantum computing.  In Proceedings of the ACM International Conference on Parallel Architectures and Compilation Techniques, pages 349–350, 2020.
  * [16] Prakash Murali, David C McKay, Margaret Martonosi, and Ali Javadi-Abhari.  Software mitigation of crosstalk on noisy intermediate-scale quantum computers.  In Proceedings of the Twenty-Fifth International Conference on Architectural Support for Programming Languages and Operating Systems, pages 1001–1016, 2020.
  * [17] Alex Parent, Martin Roetteler, and Krysta M Svore.  Reversible circuit compilation with space constraints.  arXiv preprint arXiv:1510.00377, 2015.
  * [18] Yongshan Ding, Xin-Chuan Wu, Adam Holmes, Ash Wiseth, Diana Franklin, Margaret Martonosi, and Frederic T Chong.  Square: strategic quantum ancilla reuse for modular quantum programs via cost-effective uncomputation.  In 2020 ACM/IEEE 47th Annual International Symposium on Computer Architecture (ISCA), pages 570–583. IEEE, 2020.
  * [19] Alexandru Paler, Robert Wille, and Simon J. Devitt.  Wire recycling for quantum circuit optimization.  Phys. Rev. A, 94:042337, Oct 2016.
  * [20] MD SAJID ANIS, Héctor Abraham, AduOffei, Rochisha Agarwal, Gabriele Agliardi, Merav Aharoni, Ismail Yunus Akhalwaya, Gadi Aleksandrowicz, Thomas Alexander, Matthew Amy, Sashwat Anagolum, Eli Arbel, Abraham Asfaw, Anish Athalye, Artur Avkhadiev, Carlos Azaustre, PRATHAMESH BHOLE, 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, 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, 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, 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, Eric Drechsler, Eugene Dumitrescu, Karel Dumon, Ivan Duran, Kareem EL-Safty, Eric Eastman, Grant Eberle, Amir Ebrahimi, Pieter Eendebak, Daniel Egger, ElePT, 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, Jim Garrison, Tim Gates, Leron Gil, Austin Gilliam, Aditya Giridharan, Juan Gomez-Mosquera, Gonzalo, Salvador de la Puente González, Jesse Gorzinski, Ian Gould, Donny Greenberg, Dmitry Grinko, Wen Guan, 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, Stefan Hillmich, Hiroshi Horii, Connor Howington, Shaohan Hu, Wei Hu, 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, Josh Kelso, Scott Kelso, Vismai Khanderao, Spencer King, Yuri Kobayashi, Kovi11Day, Arseny Kovyrshin, Rajiv Krishnakumar, 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, Jake Lishman, Dennis Liu, Peng Liu, 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, Cameron McGarry, David McKay, Dan McPherson, Srujan Meesala, Dekel Meirom, Corey Mendell, Thomas Metcalfe, Martin Mevissen, Andrew Meyer, Antonio Mezzacapo, Rohit Midha, Daniel 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, Jan Müggenburg, Tristan NEMOZ, David Nadlinger, Ken Nakanishi, Giacomo Nannicini, Paul Nation, Edwin Navarro, Yehuda Naveh, Scott Wyman Neagle, Patrick Neuweiler, Aziz Ngoueya, 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, Francesco Piro, Marco Pistoia, Christophe Piveteau, Julia Plewa, Pierre Pocreau, Alejandro Pozas-Kerstjens, Rafał Pracht, Milos Prokop, Viktor Prutyanov, Sumit Puri, Daniel Puzzuoli, Jesús Pérez, Quant02, Quintiii, Isha R, Rafey Iqbal Rahman, Arun Raja, Roshan Rajeev, Nipun Ramagiri, Anirudh Rao, Rudy Raymond, Oliver Reardon-Smith, Rafael Martín-Cuevas Redondo, Max Reuter, Julia Rice, Matt Riedemann, Rietesh, Drew Risinger, 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, 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, Rohan Sharma, Yunong Shi, Jonathan Shoemaker, Adenilton Silva, Andrea Simonetto, Divyanshu Singh, Parmeet Singh, Phattharaporn Singkanipa, Yukio Siraichi, Siri, Jesús Sistos, Iskandar Sitdikov, Seyon Sivarajah, 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, 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, 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, Bo Yang, Daniyar Yeralin, Ryota Yonekura, David Yonge-Mallo, Ryuhei Yoshida, Richard Young, Jessie Yu, Lebin Yu, Christopher Zachow, Laura Zdanski, Helena Zhang, Christa Zoufal, aeddins ibm, alexzhang13, b63, bartek bartlomiej, bcamorrison, brandhsn, charmerDark, deeplokhande, dekel.meirom, dime10, dlasecki, ehchen, fanizzamarco, fs1132429, gadial, galeinston, georgezhou20, georgios ts, gruu, hhorii, hykavitha, itoko, jessica angel7, jezerjojo14, jliu45, jscott2, klinvill, krutik2966, ma5x, michelle4654, msuwama, ntgiwsvp, ordmoj, sagar pahwa, pritamsinha2304, ryancocuzzo, saswati qiskit, septembrr, sethmerkel, shaashwat, sternparky, strickroman, tigerjack, tsura crisaldo, vadebayo49, welien, willhbang, wmurphy collabstar, yang.luh, and Mantas Čepulkovskis.  Qiskit: An open-source framework for quantum computing, 2021.
  * [21] Movahhed Sadeghi, Soheil Khadirsharbiyani, and Mahmut Taylan Kandemir.  Quantum circuit resizing.  arXiv preprint arXiv:2301.00720, 2022.
  * [22] Matthew DeCross, Eli Chertkov, Megan Kohagen, and Michael Foss-Feig.  Qubit-reuse compilation with mid-circuit measurement and reset, 2022.
  * [23] Fei Hua, Yuwei Jin, Yanhao Chen, John Lapeyre, Ali Javadi-Abhari, and Eddy Z Zhang.  Exploiting qubit reuse through mid-circuit measurement and reset.  arXiv preprint arXiv:2211.01925, 2022.
  * [24] Kaitlin N Smith, Gokul Subramanian Ravi, Prakash Murali, Jonathan M Baker, Nathan Earnest, Ali Javadi-Cabhari, and Frederic T Chong.  Timestitch: Exploiting slack to mitigate decoherence in quantum circuits.  ACM Transactions on Quantum Computing, 4(1):1–27, 2022.
  * [25] Poulami Das, Swamit Tannu, Siddharth Dangwal, and Moinuddin Qureshi.  Adapt: Mitigating idling errors in qubits via adaptive dynamical decoupling.  New York, NY, USA, 2021. Association for Computing Machinery.
  * [26] Gushu Li, Anbang Wu, Yunong Shi, Ali Javadi-Abhari, Yufei Ding, and Yuan Xie.  Paulihedral: a generalized block-wise compiler optimization framework for quantum simulation kernels.  In Proceedings of the 27th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, pages 554–569, 2022.
  * [27] Yasuhiro Ohkura.  Crosstalk-aware nisq multi-programming.  2021\.
  * [28] IBMQ System Report montreal description.  https://quantum-computing.ibm.com/services/resources?tab=systems&system=ibmq_montreal, 2020\.  Accessed on November 2022.
  * [29] Poulami Das, Swamit Tannu, Siddharth Dangwal, and Moinuddin Qureshi.  Adapt: Mitigating idling errors in qubits via adaptive dynamical decoupling.  In MICRO-54: 54th Annual IEEE/ACM International Symposium on Microarchitecture, pages 950–962, 2021.
  * [30] Jonas Bylander, Simon Gustavsson, Fei Yan, Fumiki Yoshihara, Khalil Harrabi, George Fitch, David G Cory, Yasunobu Nakamura, Jaw-Shen Tsai, and William D Oliver.  Noise spectroscopy through dynamical decoupling with a superconducting flux qubit.  Nature Physics, 7(7):565–570, 2011.
  * [31] Kaveh Khodjasteh and Daniel A Lidar.  Fault-tolerant quantum dynamical decoupling.  Physical review letters, 95(18):180501, 2005.
  * [32] Kaveh Khodjasteh and Daniel A Lidar.  Performance of deterministic dynamical decoupling schemes: Concatenated and periodic pulse sequences.  Physical Review A, 75(6):062310, 2007.
  * [33] Siyuan Niu and Aida Todri-Sanial.  Analyzing strategies for dynamical decoupling insertion on ibm quantum computer.  arXiv preprint arXiv:2204.14251, 2022.
  * [34] Arturo Mena López and Lian-Ao Wu.  Protectability of ibmq qubits by dynamical decoupling technique.  Symmetry, 15(1):62, 2023.
  * [35] 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.
  * [36] Ang Li, Samuel Stein, Sriram Krishnamoorthy, and James Ang.  Qasmbench: A low-level qasm benchmark suite for nisq evaluation and simulation.  arXiv preprint arXiv:2005.13018, 2020.
  * [37] Gokul Subramanian Ravi, Kaitlin N Smith, Prakash Murali, and Frederic T Chong.  Adaptive job and resource management for the growing quantum cloud.  In 2021 IEEE International Conference on Quantum Computing and Engineering (QCE), pages 301–312. IEEE, 2021.
  * [38] Xiangzhen Zhou, Sanjiang Li, and Yuan Feng.  Quantum circuit transformation based on simulated annealing and heuristic search.  IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 39(12):4683–4694, dec 2020.