# Bipartite entanglement of noisy stabilizer states through the lens of
stabilizer codes

Kenneth Goodenough  Computer Science
UMass Amherst  Aqil Sajjad  Optical Sciences
Univ. of Arizona  Eneet Kaur  Optical Sciences
Univ. of Arizona  Cisco Quantum Lab  Saikat Guha  Optical Sciences
Univ. of Arizona  Don Towsley  Computer Science
UMass Amherst

###### Abstract

Stabilizer states are a prime resource for a number of applications in quantum
information science, such as secret-sharing and measurement-based quantum
computation. This motivates us to study the entanglement of noisy stabilizer
states across a bipartition. We show that the spectra of the corresponding
reduced states can be expressed in terms of properties of an associated
stabilizer code. In particular, this allows us to show that the coherent
information is related to the so-called syndrome entropy of the underlying
code. We use this viewpoint to find stabilizer states that are resilient
against noise, allowing for more robust entanglement distribution in near-term
quantum networks. We specialize our results to the case of graph states, where
the found connections with stabilizer codes reduces back to classical linear
codes for dephasing noise. On our way we provide an alternative proof of the
fact that every qubit stabilizer code is equivalent up to single-qubit
Clifford gates to a graph code.

##  I Introduction

Entanglement forms the core principle behind many applications of quantum
communication. The entanglement of stabilizer states has been found to be a
resource vital for sensing, secret-sharing and computation [1, 2, 3, 4, 5, 6,
7]. Distributing such states is a non-trivial task, and inevitably leads to
noise being imparted unto the state. In this work, we are concerned with
finding stabilizer states whose entanglement is robust against noise. As a
quantifier of the entanglement, we use the coherent information, which is a
lower bound on the distillable entanglement [8].

To find robust states, we first need to be able to describe a stabilizer state
after noise has been applied. For our error model (consisting of uniform
depolarizing noise) we show that the total state and its marginals are
described in terms of stabilizer codes associated with the state. As we
motivate and confirm numerically, the robustness of the state is directly
linked to the underlying stabilizer codes.

######  Theorem 1.

(Informal) The coherent information of a noisy stabilizer state $\rho_{AB}$
with respect to a bipartition $A,B$ is given by

$\displaystyle\hat{S}(\rho_{B})-\hat{S}(\rho_{AB})=k+S(\mathbf{s}_{B})-S(\mathbf{s}_{AB})\
,$ (1)

where $\hat{S}\left(\cdot\right)$ indicates the von Neumann entropy, and
$S(\mathbf{s}_{B})$ and $S(\mathbf{s}_{AB})$ are _syndrome entropies_ [9, 10,
11, 12, 13] of two stabilizer codes (with parameters
$\left[n+k,0,d^{\prime}\right]$ and $\left[n,k,d\right]$) associated with
$\rho_{AB}$.

We clarify in the main text how to construct the two associated stabilizer
codes. We show that the above syndrome entropies can be expressed in terms of
so-called weight enumerator polynomials for uniform depolarizing noise.

We further specialize Theorem 1 to graph states (which are stabilizer states
that are constructed by applying controlled-$Z$ ($\mathrm{CZ}$) gates to
qubits in the $\ket{+}$ state), where we show how to deal with dephasing and
depolarizing noise applied both before and after application of the
$\mathrm{CZ}$ gates. For dephasing, we find a link between the robustness of
the state and classical codes.

######  Theorem 2.

(Informal) The coherent information of a graph state $\rho_{AB}$ that has
undergone uniform dephasing with parameter $p$ with respect to a bipartition
$A,B$ is given by

$\displaystyle\hat{S}(\rho_{B})-\hat{S}(\rho_{AB})=k+S(\mathbf{s}_{B})-\left(n+k\right)\overline{S}\left(p\right)\
,$

where $n+k$ equals the total number of qubits, $S(\cdot)$ is the syndrome
entropy of a classical code whose generator matrix is given by the biadjacency
matrix of the bipartite graph consisting of edges between $A$ and $B$, and
$\overline{S}\left(\cdot\right)$ is the binary entropy.

The above two results aid in calculating the coherent information manner of
noisy stabilizer states, which is more tractable than the naive approach of
diagonalizing the density matrices directly. Furthermore, since the coherent
information can be phrased entirely in terms of properties of the associated
code, a first intuition would be that graphs with good associated codes
provide robustness against noise, at least in the low noise regime. We confirm
this intuition numerically in the main text.

Our results follow from interpreting stabilizer codes as arising from
_contraction_ and _deletion_ operations on stabilizer states. We use this
perspective to give alternative proofs of 1) that every stabilizer code is
equivalent to a graph code, 2) a graph-theoretic description of equivalent
graph codes.

##  II Preliminaries

We use most of the standard notation used for graphs, classical codes,
stabilizer states and graph states. The set of all Pauli strings on $n$ qubits
is denoted by $\mathcal{P}_{n}$. A commutative subgroup $H$ of
$\mathcal{P}_{n}$ that does not contain $-I$ is called a stabilizer group.
Associated with each such $H$ with $|H|=2^{n-k}$ is an $\left[n,k,d\right]$
code. That is, it is the unique subspace that is point-wise fixed by each
$h\in H$. We use the term code to refer to both subspaces and their associated
stabilizer groups. In this paper, we ignore phases of Pauli strings. Each
stabilizer group also has a group of logical operators,
$H_{\textrm{logical}}$. We use the convention that this group consists of all
elements in $\mathcal{P}_{n}$ which commute with all elements in $H$.

Given a generating set of a stabilizer group $H$, a syndrome is often defined
as an observed measurement pattern when measuring the elements from the
generating set. Note that this definition depends on an arbitrary choice of
the generating set. A more abstract definition exists for syndromes that does
not depend on such a choice. Namely, syndromes are identified as the cosets
$P\cdot H_{\textrm{logical}}$ for $P\in\mathcal{P}_{n}$. The first definition
can be recovered by noting that two elements are in the same coset iff they
have the same (anti-)commutation relations with any generating set.

A graph state can be defined as the state reached after applying $\mathrm{CZ}$
gates according to the edges of a graph $G$ to $\ket{+}^{\otimes n}$. Since
$\mathrm{CZ}$ gates commute, this is well-defined. A graph state can also be
defined by a natural generating set of its stabilizer group, which is given by
$X_{v}\prod_{w\in N_{v}}Z_{w}$ for each vertex $v\in V$ [14].

Each element $P\in\mathcal{P}_{n}$ has a _weight_ $\textrm{wt}\left(P\right)$,
i.e. $\textrm{wt}\left(P\right)$ counts the number of non-identity elements in
$P$. For an arbitrary subset $K\subseteq\mathcal{P}_{n}$, define
$\mathcal{W}_{w}\left(K\right)$ to be the number of elements in $K$ with
weight equal to $w$. The _weight enumerator polynomial of $K$_ is defined as
$\mathcal{W}\left(K,x,y\right)=\sum_{w=0}^{n}\mathcal{W}_{w}\left(K\right)x^{n-w}y^{w}$
[15].

The depolarizing channel on a single qubit is given by
$D(\cdot)=\lambda\left(\cdot\right)+\left(1-\lambda\right)\textrm{Tr}\left(\cdot\right)\frac{I}{2}$
for some $\lambda\in\left[0,1\right]$111Although we do not consider it here,
technically $\lambda$ can take values outside of this range while still
leading to a valid quantum channel.. Alternatively, with probability $\lambda$
no noise is applied, while with probability $1-\lambda$ a single-qubit Pauli
$I,X,Y,Z$ is applied with uniform probability. Generalizing to uniform
depolarizing noise on $n$ qubits, we find that a Pauli string $P$ with weight
$\textrm{wt}(P)$ is applied with probability
$\left(\lambda+\frac{1-\lambda}{4}\right)^{n-\textrm{wt}\left(P\right)}\left(\frac{1-\lambda}{4}\right)^{\textrm{wt}\left(P\right)}=\frac{1}{4^{n}}\left(1+3\lambda\right)^{n-\textrm{wt}\left(P\right)}\left(1-\lambda\right)^{\textrm{wt}\left(P\right)}$.

We are interested in bipartite entanglement between Alice and Bob, where we
assume that Alice holds $k$ qubits and Bob holds $n$ qubits. This convention
is convenient for relating properties to $\left[n,k,d\right]$ codes. Finally,
we use the shorthand notation $U(A)\equiv UAU^{\dagger}$.

###  II-A Contraction and deletion

In this section we present two important operations, _contraction_ and
_deletion_.

######  Definition 1.

The deletion of a subset of qubits $T$ of a stabilizer group $H$ yields a new
group $H\backslash T$. The group $H\backslash T$ has the same elements as $H$,
but with the entries corresponding to $T$ removed. We also use $h\backslash T$
when deleting entries only from a single element $h\in H$.

######  Definition 2.

The contraction of a subset of qubits $T$ of a stabilizer group $H$ yields a
new group $H/T$. The group $H/T$ consists of those elements of $H$ that do not
have support on $T$. Furthermore, the entries corresponding to $T$ are
removed.

When deleting (contracting) a singleton set $\\{{t\\}}$ we write $H\backslash
t$ ($H/t$). Deletions and contractions are closely connected through the
_dual_ operation.

######  Definition 3.

The dual of a subgroup $H$ of $\mathcal{P}_{n}$ (which need not be a
stabilizer group) is the largest subgroup $H^{\perp}$ of $\mathcal{P}_{n}$
that commutes elementwise with all elements of $H$.

The dual of the stabilizer group of a code is exactly the group of logical
operators of that code, i.e. $H^{\perp}=H_{\textrm{logical}}$ [15].
Furthermore, the dual operation is an involution. Contraction and deletion are
related through the dual operation as follows

$\displaystyle(H\backslash T)^{\perp}$
$\displaystyle=\left(H^{\perp}\right)/T\ ,$ (2)
$\displaystyle\left(H/T\right)^{\perp}$
$\displaystyle=\left(H^{\perp}\right)\backslash T\ .$ (3)

We show an example of the contraction and deletion operations for the complete
graph state on three vertices in Fig. 1.

$1$$2$$3$$H=$ $III$ $YYI$ $XZZ$ $YIY$ $ZXZ$ $IYY$ $ZZX$ $XXX$ $H\backslash 1=$
$I_{L}=II$ $Y_{L}=YI$ $X_{L}=ZZ$ $Y_{L}=IY$ $Z_{L}=XZ$ $I_{L}=YY$ $Z_{L}=ZX$
$X_{L}=XX$ $H/1=$ $II$ $YY$ Figure 1: Example of the contraction and deletion
operation on a single qubit of a stabilizer state. We choose the complete
graph state $\ket{K_{3}}$, which has stabilizer group
$\\{{III,XZZ,ZXZ,ZZX,YYI,YIY,IYY,XXX\\}}$. Contracting the first qubit yields
the code $H/1=\\{{II,YY\\}}$, while deletion yields $H\backslash
1=\\{{II,ZZ,XZ,ZX,YI,IY,YY,XX\\}}$. Note that $H\backslash 1$ is the group of
logical operators of the stabilizer code $H/1$. Furthermore, the _type_ of
logical operator of an element $h\backslash 1$ is given by
$h\backslash\\{2,3\\}$, e.g. $ZZX\backslash 1=ZX$ implements a logical $Z$
since $ZZX\backslash\\{2,3\\}=Z$.

The contraction and deletion perspectives are used to reason about marginals
of stabilizer states, and especially to relate them to stabilizer codes. As an
example of this perspective, note contracting a subset of qubits of a
stabilizer state yields a stabilizer code. We show that every stabilizer code
arises in this fashion.

######  Lemma 1.

For every stabilizer group $H$ on a set of qubits $V$ there exists a
stabilizer group $\overline{H}$ of a stabilizer state on a set of qubits
$V^{\prime}\cup V$ such that $H=\overline{H}/V^{\prime}$.

###### Proof.

See Appendix A. ∎

Given such an $\overline{H}$ for a stabilizer group
$H=\overline{H}/V^{\prime}$, we find through the duality relations in Eq. (2)
and (3) that the group of logical operators is given by
$H^{\perp}=\overline{H}\backslash V^{\prime}$. Furtheremore, there is a
canonical way to assign the _type_ of logical operator to the element
$h\backslash T\in H\backslash T$. That is, we say that $h\backslash T$
implements the logical operator of type $h\backslash(V-T)$, i.e. how $h$ acts
on the complement of $T$ (see Fig. 1).

Lemma 1 also allows for a straightforward proof that every stabilizer code can
be thought of as a _graph code_ (first shown but phrased differently in [16,
17]). A graph code can be defined in several different ways. One way is the
operational interpretation from [14]. Here, $k$ input qubits are prepared in
an arbitrary state, $n$ output qubits are initialized in $\ket{+}$, and then
$\mathrm{CZ}$ gates are performed according a given graph $G$. After the
$\mathrm{CZ}$ gates, the input qubits are measured in the $X$ basis. The input
state is now encoded on the $n$ output qubits (up to some unimportant outcome-
dependent local corrections). This can be shown to be equivalent to
implementing a code whose stabilizer group corresponds to deletion of the
input qubits on the graph state $\ket{G}$ [18].

######  Theorem 3.

Every stabilizer code is single-qubit Clifford equivalent to a graph code.

###### Proof.

The statement is equivalent to the claim that every stabilizer group $H$ is
single-qubit Clifford equivalent to $\overline{H}/T$ for some set $T$ and
$\overline{H}^{\prime}$ the stabilizer group of a graph state. From Lemma 1 we
know that there exists some stabilizer group $\overline{H}$ of a stabilizer
state (not necessarily a graph state) such that $\overline{H}/T=H$. By
definition, we are free to perform single-qubit Clifford operations on the
complement of $T$. However, for $U$ an arbitrary unitary local to $T$,
$H/T=U(H)/T$. This means that we are free to apply single-qubit Clifford
operations to _all_ qubits of $\overline{H}$. Using that every stabilizer
state is single-qubit Clifford equivalent to a graph state [19] the claim
follows. ∎

The above is also an alternative proof of Corollary IV.6 in [18].

We make one technical assumption for the remainder of this paper. We assume
that deletions preserve the cardinality of the group. This is to ensure that
the $k$ qubits on Alice’s side can still be interpreted as the code parameter
$k$, see Section V.A of [18] for a more detailed discussion.

###  II-B Conjugate codes/subspaces

Any stabilizer code $H$ has several closely associated codes, which differ
only by phases $\pm 1$ in front of the $h\in H$. We call these the conjugate
codes/subspaces of $H$. We collect here several useful characterizations of
these codes and their associated subspaces. First, not every combination of
phases is possible. For a fixed generating set of size $n-k$ of $H$, all other
conjugate codes are generated by the same generating set, but by selecting for
each of the $n-k$ generators whether it has a minus sign in front of the
generator or not. As an example, $\langle XX,ZZ\rangle$ has the four conjugate
codes $\langle\pm XX,\pm ZZ\rangle$. Alternatively, the choice of $\pm 1$ for
each generator can be interpreted as a homomorphism from $H$ to
$\\{{-1,1\\}}$. In fact, the different homomorphisms $H\mapsto\\{{-1,1\\}}$
form all the possible _characters_ of $H$, i.e. homomorphisms from $H$ to
$\mathbb{C}$.

Second, any two different such subspaces are orthogonal. This is because they
differ in the phase of at least one stabilizer, meaning that any two states in
two different conjugate subspaces can be deterministically distinguished by
measuring that stabilizer. Note that this argument still holds for mixed
states that are convex combinations of basis states of the respective
subspaces.

Since the $2^{n-k}$ conjugate subspaces (corresponding to the $2^{n-k}$
possible assignments of $\pm 1$ for each of the $n-k$ generators) are
orthogonal and each has dimension $2^{k}$, the entire space is a direct sum of
the conjugate subspaces. Now note that the operator $\sum_{h\in H}h$ acts as
the identity on its associated subspace. What is more, the kernel of
$\sum_{h\in H}h$ is given by the direct sum of all the other conjugate
subspaces. This is because for any $\ket{\psi}$ in a different conjugate
subspace $H^{\prime}$, the two cases $h\ket{\psi}=\pm\ket{\psi}$ appear
equally often222On a deeper level this follows from the orthogonality of
irreducible characters, such that the above result also generalizes to prime
qudit stabilizers.. Summarizing, $\sum_{h\in H}h$ is the projector onto the
stabilizer codespace $H$.

We often need to refer to states that are normalized projectors into
stabilizer codespaces, i.e. $\frac{1}{\left|H\right|}\sum_{h\in
H}h\equiv\rho_{H}$. We abuse terminology and refer to such states as code
projectors, even though $\rho_{H}^{2}$ only equals $\rho_{H}$ up to a scalar.

The following lemma details how different Pauli operators affect
codespaces/code projectors.

######  Lemma 2.

Let $\rho_{H}$ be a code projector with associated stabilizer group $H$ and
$P\in\mathcal{P}_{n}$. Then $P\left(\rho_{H}\right)\equiv
P\rho_{H}P^{\dagger}=\rho_{P(H)}=\sum_{h\in H}P(h)$ equals $\rho_{H}$ iff
$P\in H^{\perp}$. If $P\not\in H^{\perp}$ then $\rho_{H}$ and $\rho_{P(H)}$
are distinct conjugate code projectors.

###### Proof.

If $h^{\prime}\in H^{\perp}$, then by definition $h^{\prime}$ commutes with
each $h\in H$, so that $h^{\prime}(\rho_{H})=\rho_{H}$. Otherwise,
$h^{\prime}$ anti-commutes with exactly half the elements of $H$. This leads
to phases being added in front of the anti-commuting terms, yielding a
conjugate code. ∎

In fact, $P(\rho_{H})$ depends only on the coset of $H^{\perp}$ in
$\mathcal{P}_{n}$ that $P$ belongs to, since two elements $h,h^{\prime}$ are
in the same coset iff they are the same up to multiplication by an element in
$H^{\perp}$. We label the cosets of $H^{\perp}$ in $\mathcal{P}_{n}$ by
$C_{e}$. Note that $H^{\perp}$ is a normal subgroup of $\mathcal{P}_{n}$. We
call a generating set $E$ of $\mathcal{P}_{n}$ modulo $H^{\perp}$ an _error
basis_.

##  III Results

In this section we detail how to calculate the states $\rho_{AB}$ and
$\rho_{B}$ under depolarizing noise. First, we show that the marginal
$\rho_{B}$ can be interpreted in terms of deletion/contraction of the
stabilizer group $H$ of $\rho_{AB}$, i.e. we show that $\rho_{B}=\rho_{H/A}$.
Second, we use the fact that $P\in\mathcal{P}_{n}$ maps $\rho_{H}$ to
$\rho_{H^{\prime}}$, where the $H^{\prime}$ depends only on which coset of
$H^{\perp}$ in $\mathcal{P}_{n}$ the element $P$ belongs to.

To start, note that without noise states $\rho_{AB}$ and $\rho_{A}/\rho_{B}$
are code projectors. This is trivially true for $\rho_{AB}$. For the
marginals, we have the following result (see also [20])

######  Proposition 1.

Let $\rho_{AB}$ be a pure stabilizer state with stabilizer group $H$. Then
$\rho_{B}$ is the code projector with stabilizer group $H/A$.

###### Proof.

Since $\rho_{AB}$ is a code projector, we have that $2^{n}\rho_{AB}=\sum_{h\in
H}h$. Note that tracing out the $A$ system leaves only the terms that act as
the identity on the $A$ system. This follows from linearity of the trace, that
the trace is multiplicative over tensor products, and that
$\Tr{I}=2,~{}\Tr{X}=\Tr{Y}=\Tr{Z}=0$. ∎

The above proposition also generalizes to marginals of code projectors.

From Lemma 2 we find that applying Pauli noise to a code projector $\rho_{H}$
yields probabilistic mixtures of the different conjugate states
$\rho_{H^{\prime}}$333For non-trivial depolarizing each possible conjugate
code has a non-zero probability mass. This need not be true for dephasing or
general Pauli noise.. Then, to fully characterize the final state, it suffices
to calculate the probability $\textrm{Prob}\left(\rho_{H^{\prime}}\right)$
with which each $\rho_{H^{\prime}}$ appears when applying depolarizing noise
to $\rho_{H}$. Let $C_{e}$ be the coset that takes $\rho_{H}$ to
$\rho_{H^{\prime}}$ (see Lemma 2). We find

$\displaystyle\textrm{Prob}(\rho_{H^{\prime}})=$
$\displaystyle\sum_{\mathclap{\begin{subarray}{c}P\in\mathcal{P}_{n}\\\
\textrm{s.t. }P(\rho_{H})=\rho_{H^{\prime}}\end{subarray}}}\textrm{Prob}(P)$
(4) $\displaystyle=$ $\displaystyle\sum_{P\in C_{e}}\textrm{Prob}(P)$ (5)
$\displaystyle=$ $\displaystyle\frac{1}{4^{n}}\sum_{P\in
C_{e}}\left(1+3\lambda\right)^{n-\textrm{wt}\left(P\right)}\left(1-\lambda\right)^{\textrm{wt}\left(P\right)}$
(6) $\displaystyle=$
$\displaystyle\frac{1}{4^{n}}\mathcal{W}\left(C_{e},1+3\lambda,1-\lambda\right)\
.$ (7)

where we assume uniform depolarizing noise to express the final result in
terms of weight enumerators.

With the appropriate machinery in hand, it is straightforward to compute the
entropy of a code projector that has undergone depolarizing noise. Since the
state is a convex combination of orthogonal projectors, the associated
probability distribution factorizes. That is, the probability distribution
associated with an eigenstate of the noisy code projector can be thought of as
first randomly selecting which one of the codespaces $H$ one belongs to (with
probability $\textrm{Prob}\left(\rho_{H}\right)$), and then uniformly at
random selecting one of the $2^{k}$ basis states of the code space.

The associated entropy is thus given by

$\displaystyle\hat{S}(D(\rho_{H}))=k+S(\mathbf{s}_{H})\ ,$ (8)

where $S(\mathbf{s}_{H})$ is the so-called _syndrome entropy_ of the code $H$
[9, 10, 11, 12, 13]. That is, it is the entropy of the probability
distribution associated with observing the different possible syndromes s. The
syndrome entropy has been studied before in the context of classical codes,
having appeared already in the original work of Gallagher on LDPC codes [9].

From Eq. (8) our main theorem follows.

######  Theorem 4.

The coherent information of a stabilizer state across a bipartition $A,B$ that
underwent uniform depolarizing noise is given by

$\displaystyle\hat{S}(\rho_{B})-\hat{S}(\rho_{AB})=k+S(\mathbf{s}_{H\backslash
A})-S(\mathbf{s}_{H})\ ,$ (9)

where $H$ is the stabilizer group of the state shared between Alice and Bob.
The distributions $\mathbf{s}_{H\backslash A}$ and $\mathbf{s}_{H}$ can be
expressed in terms of weight enumerators.

In the above, we interpreted the syndrome entropy of a code $H\backslash A$.
However, $H\backslash A$ is not an actual stabilizer group and thus the
syndrome entropy does not correspond to the entropy of a stabilizer code that
can be realized in experiment. However, $H\backslash A$ (and its syndrome
entropy) can still be interpreted as arising from a classical linear code over
the field of four elements [21].

###  III-A Algorithm

We now sketch our algorithm for calculating the coherent information of a
stabilizer state that underwent uniform depolarizing noise. The goal is to
construct an error basis $E$. $E$ is then used to reconstruct the cosets
$C_{e}$, from which one can calculate the syndrome entropy through Eq. (7).

Let us first focus on the $\rho_{AB}$ term. Assume that a stabilizer tableau
$M$ (represented as an element of $\mathbb{F}_{2}^{(n+k)\times 2(n+k)}$) is
given for the initial state $\ket{\psi}$. This matrix has rank $n+k$ over
$\mathbb{F}_{2}$. Our goal is to find an error basis $E$, from which the
cosets $C_{e}$ can be reconstructed. The error basis $E$ is of size $n+k$ and
each of its elements is linearly independent from $M$. We construct such a
basis $E$ as follows. Initialize $E$ as the empty set. Start with $M$ and
check whether $e_{1}$ is in the row span of $M$, where $e_{i}$ is the $i$’th
standard basis vector. It suffices to check whether $M$ and $M$ with the added
row $e_{1}$ have the same rank over $\mathbb{F}_{2}$. If the rank increases,
add $e_{1}$ to $E$ and add $e_{1}$ as a row vector to $M$. Now repeat the
procedure but with $e_{2}$, and repeat until the matrix has maximum rank.

The procedure is essentially the same for the $\rho_{B}$ term with the
stabilizer tableau444Often the term stabilizer tableau is reserved for
commutative subgroups, which we do not restrict ourselves to here. associated
with $H\backslash A$ replacing the one associated with $H$. The new stabilizer
tableau is the same as the original $M$, but with the columns indexed by $A$
removed. As before, one adds basis elements to the stabilizer tableau and
error basis $E$ every time it is linearly independent from the rest.

Let us consider the example in Fig. 1. Two natural stabilizer tableaux of $H$
and $H\backslash 1$ are given by

$\displaystyle M=\begin{bmatrix}1&0&0&0&1&1\\\ 0&1&0&1&0&1\\\ 0&0&1&1&1&0\\\
\end{bmatrix},\quad M^{\prime}=\begin{bmatrix}0&0&1&1\\\ 1&0&0&1\\\ 0&1&1&0\\\
\end{bmatrix}\ .$

Finding an error basis for $M$ is straightforward, since distinct $Z$-type
operators map graph states to distinct orthogonal states. In other words,
$E=\\{e_{1+3},e_{2+3},e_{3+3}\\}$. The same argument does not hold for
$M^{\prime}$, but fortunately the first pick $e_{1}$ suffices, i.e.
$E=\\{{e_{1}\\}}$. For simplicity, we calculate only the probability
distribution over cosets corresponding to $M^{\prime}$. That is, the
probability distribution that has entropy $S(\mathbf{s}_{H\backslash 1})$.

Writing out the full cosets as Pauli operators yields

$\displaystyle\begin{array}[]{ccc}\textrm{Row}(M^{\prime})&&e_{1}+\textrm{Row}(M^{\prime})\\\
\downarrow&&\downarrow\\\ \begin{bmatrix}0&0&0&0\\\ 0&0&1&1\\\ 1&0&0&1\\\
0&1&1&0\\\ 1&0&1&0\\\ 0&1&0&1\\\ 1&1&1&1\\\ 1&1&0&0\\\
\end{bmatrix}&&\begin{bmatrix}1&0&0&0\\\ 1&0&1&1\\\ 0&0&0&1\\\ 1&1&1&0\\\
0&0&1&0\\\ 1&1&0&1\\\ 0&1&1&1\\\ 0&1&0&0\\\ \end{bmatrix}\\\
\downarrow&&\downarrow\\\ \begin{bmatrix}II&YI\\\ ZZ&IY\\\ XZ&YY\\\ ZX&XX\\\
\end{bmatrix}&&\begin{bmatrix}XI&ZI\\\ YZ&XY\\\ IZ&ZY\\\ YX&IX\\\
\end{bmatrix}\\\ \downarrow&&\downarrow\\\ H\backslash
1&&XI\cdot\left(H\backslash 1\right)\ .\end{array}$ (17)

By construction, the two cosets only differ in their first entries. The weight
distributions
$\left(\mathcal{W}_{0}(C_{e}),\mathcal{W}_{1}(C_{e}),\mathcal{W}_{2}(C_{e})\right)$
of the two cosets are given by $(1,2,5)$ and $(0,4,4)$, respectively. Using
(7) and the fact that there are only two cosets, we find that the entropy of
the reduced state after depolarizing is given by

$\displaystyle S\left(D\left(\rho_{H\backslash 1}\right)\right)=~{}$
$\displaystyle k+S(\mathbf{s}_{H\backslash 1})$ $\displaystyle=~{}$
$\displaystyle
1+\overline{S}\left(\frac{4\left(1+3\lambda\right)\left(1-\lambda\right)+4\left(1-\lambda\right)^{2}}{4^{2}}\right)$
$\displaystyle=~{}$ $\displaystyle
1+\overline{S}\left(\frac{1-\lambda^{2}}{2}\right)\ .$

###  III-B Reduction for dephasing on graph states

Here we limit our discussion to graph states and dephasing on them, and show
how the above connections reduce to classical linear codes.

Let us define dephasing with the following parameterization,
$D_{Z}(\cdot)=p(\cdot)+\left(1-p\right)Z(\cdot)$.

######  Theorem 5.

Let $\ket{G}$ be a graph state whose biadjacency matrix across a bipartition
$A,B$ is given by $G_{AB}$. The coherent information of $\ket{G}$ after
uniform dephasing with parameter $p$ with respect to a bipartition $A,B$ is
given by

$\displaystyle
S(\rho_{B})-S(\rho_{AB})=k+S(\mathbf{s}_{G_{AB}})-\left(n+k\right)\overline{S}(p)\
,$ (18)

where $S(\mathbf{s}_{G_{AB}})$ is the syndrome entropy of the linear code with
generator matrix $G_{AB}$.

###### Proof.

Since $\mathrm{CZ}$ gates commute with $Z$ gates, the entropy of $\rho_{AB}$
is given by $\left(n+k\right)\cdot
S(\\{p,1-p\\})\equiv\left(n+k\right)\cdot\overline{S}(p)$. Further, we are
free to remove local $\mathrm{CZ}$ gates. We thus restrict ourselves to
bipartite graphs.

To continue, we need to construct the stabilizer tableau after deletion. We
find that

$\displaystyle\left[\begin{array}[]{c|c|c|c}&&&\\\ I_{k}&\>0&\>0&G_{AB}\\\
&&&\\\ \hline\cr&&&\\\ \>0&I_{n}&G_{AB}^{T}&\>0\\\
&&&\end{array}\right]\xrightarrow{\textrm{deletion}}\left[\begin{array}[]{c|c}0&G_{AB}\\\
\hline\cr&\\\ I_{n}&\>0\\\ &\end{array}\right],\ $ (29)

where $G_{AB}$ is the biadjacency matrix across the bipartition.

Now, only $Z$ errors occur, which act on the $G_{AB}$ part. This means that
$G_{AB}$ can be interpreted as the generator matrix of a classical code. As
before, we are interested in the probability distribution over the
cosets/syndromes. In this case $S(\mathbf{s})$ reduces to the syndrome entropy
of the classical linear code with generator matrix $G_{AB}$. ∎

The coherent information for dephasing noise can be calculated using a similar
technique as for depolarizing noise.

We close with two comments. First, assume the graph state in question has been
created by first preparing $\ket{+}^{\otimes n}$ and then applying
$\mathrm{CZ}$ gates. We can include noisy preparation of the $\ket{+}^{\otimes
n}$, where we can include both depolarizing and dephasing noise. This follows
from the fact that depolarizing acts as dephasing on $\ket{+}^{\otimes n}$,
and that $Z$ gates commute with $\mathrm{CZ}$ gates. Second, we can also
include depolarizing noise after the $\mathrm{CZ}$ gates has been applied. Let
$Q_{1}(s)$ and $Q_{2}(s)$ be the probabilities for seeing a syndrome $s$ for
dephasing and depolarizing noise separately. Then the probability $Q_{3}(s)$
of seeing a syndrome $s$ for the combined models is given by

$\displaystyle Q_{3}(s)=\sum_{\mathclap{\begin{subarray}{c}s_{1},s_{2}\\\
\textrm{s.t. }s_{1}\oplus s_{2}=s\end{subarray}}}Q_{1}\left(s_{1}\right)\cdot
Q_{2}\left(s_{2}\right)\ .$ (30)

That is, thinking of $Q_{1}$, $Q_{2}$ as functions on $\mathbb{Z}_{2}^{n-k}$,
$Q_{3}$ is the convolution of $Q_{1}$ and $Q_{2}$ with respect to the group
$\mathbb{Z}_{2}^{n-k}$. One can also apply the associated Fourier transform
(the Hadamard Transform) to the $Q_{1}$ and $Q_{2}$, multiply them pointwise,
and perform the inverse Fourier transform [22]. We do not report any numerics
for the case of both dephasing and depolarization.

##  IV Numerical results

We plot the coherent information for several noisy stabilizer states in Fig.
3. We consider here the graph states associated with a single Bell pair, the
repetition code on seven qubits, the 5-qubit code, the $\left[4,2,2\right]$
code and the $\left[8,3,3\right]$ code. As noted before, several choices of
graph states lead to equivalent projectors, but the syndrome entropy of the
total graph state may differ. We show the two graphs that we consider for the
$\left[4,2,2\right]$ code in Fig. 2. Finally, for the $\left[8,3,3\right]$
code [23] we use the graph state from [24]).

Figure 2: The two graphs used associated with the $\left[4,2,2\right]$ code,
where they only differ in the dashed line. Both states have the same marginal
on the non-diamond qubits, but differ in the complement marginal.

We observe that better codes lead to more robust states. Note that the two
states associated with the $\left[4,2,2\right]$ code have the same reduced
entropies but differ in their syndrome entropy of the $\left[n+k,0,d\right]$
code associated with the total graph state.

Figure 3: Comparison of the coherent information for several different graph
states under depolarizing noise.

In Fig. 4 we compare the coherent information for several different graph
states under dephasing noise. We see that the repetition codes can achieve
non-zero coherent information for larger values of dephasing parameter, $p$
(due to the fact that the distance increases), similar to the results from
[25]. On the other hand the coherent information is small even for little
dephasing (i.e. $p$ large), since repetition codes have $k=1$.

Figure 4: Comparison of the coherent information for several different graph
states under dephasing noise.

We see that the robustness of stabilizer states is correlated with how good
the associated codes are, for both dephasing and depolarizing noise.

##  V Discussion

In this paper we interpreted noisy stabilizer states in terms of certain
associated stabilizer codes. This suggests that stabilizer states robust
against noise/distribution in networks have good codes associated to them; we
confirmed this intuition for a number of codes. However, there seems no
structural way to find the state with the largest coherent information for
fixed $n$, $k$ and noise parameter $\lambda$. This should come as no surprise,
since finding optimal codes for any metric is a difficult task.

On a higher level, we have shown that the spectra of noisy stabilizer states
can be expressed in terms of weight enumerators, quantities that are known to
be hard to compute (even in the classical case) but have been well-studied
[26, 27, 28]. Fortunately bounds on the syndrome entropy have been
investigated for the classical case; it would be of interest to see if those
results can be exploited for the case considered here. This would however
require a good enough control on the error terms, since the coherent
information involves the difference of two syndrome entropies.

The techniques developed here apply straightforwardly to the multipartite
setting. One possible application would be to express upper bounds [29, 30] on
the multipartite squashed entanglement [31] to find upper bounds on the
multipartite distillable key.

##  VI Acknowledgements

The authors would like to extend thanks to Dion Gijswijt for discussions on
contractions, deletions and related topics. This work was funded by the Army
Research Office (ARO) MURI on Quantum Network Science under grant number
W911NF2110325.

## References

  * [1] P. W. Shor, “Scheme for reducing decoherence in quantum computer memory,” _Phys. Rev. A_ , vol. 52, pp. R2493–R2496, Oct 1995. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevA.52.R2493
  * [2] S. Bartolucci, P. Birchall, H. Bombin, H. Cable, C. Dawson, M. Gimeno-Segovia, E. Johnston, K. Kieling, N. Nickerson, M. Pant, F. Pastawski, T. Rudolph, and C. Sparrow, “Fusion-based quantum computation,” 2021.
  * [3] A. Kitaev, “Fault-tolerant quantum computation by anyons,” _Annals of Physics_ , vol. 303, no. 1, pp. 2–30, Jan. 2003. [Online]. Available: https://doi.org/10.1016/s0003-4916(02)00018-0
  * [4] R. Raussendorf and H. J. Briegel, “A one-way quantum computer,” _Phys. Rev. Lett._ , vol. 86, pp. 5188–5191, May 2001. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevLett.86.5188
  * [5] N. Sangouard, C. Simon, H. de Riedmatten, and N. Gisin, “Quantum repeaters based on atomic ensembles and linear optics,” _Rev. Mod. Phys._ , vol. 83, pp. 33–80, Mar 2011. [Online]. Available: https://link.aps.org/doi/10.1103/RevModPhys.83.33
  * [6] K. Azuma, K. Tamaki, and H.-K. Lo, “All-photonic quantum repeaters,” _Nature Communications_ , vol. 6, no. 1, Apr. 2015. [Online]. Available: https://doi.org/10.1038/ncomms7787
  * [7] N. Shettell and D. Markham, “Graph states as a resource for quantum metrology,” _Phys. Rev. Lett._ , vol. 124, p. 110502, Mar 2020. [Online]. Available: https://link.aps.org/doi/10.1103/PhysRevLett.124.110502
  * [8] B. Schumacher and M. A. Nielsen, “Quantum data processing and error correction,” _Physical Review A_ , vol. 54, no. 4, p. 2629, 1996.
  * [9] R. Gallager, “Low-density parity-check codes,” _IRE Transactions on information theory_ , vol. 8, no. 1, pp. 21–28, 1962.
  * [10] P. Grover and A. K. Chaturvedi, “Upper bounds on the rate of ldpc codes for a class of finite-state markov channels,” _IEEE transactions on information theory_ , vol. 53, no. 2, pp. 794–804, 2007.
  * [11] T. Wadayama, “Ensemble analysis on syndrome entropy of binary linear codes,” in _2006 IEEE International Symposium on Information Theory_. IEEE, 2006, pp. 1559–1563.
  * [12] D. Matas and M. Lamarca, “Analysis of ldpc code syndrome entropy based on subgraphs,” in _2016 9th International Symposium on Turbo Codes and Iterative Information Processing (ISTC)_. IEEE, 2016, pp. 315–319.
  * [13] J. Li, Z. Tu, and R. S. Blum, “Slepian-wolf coding for nonuniform sources using turbo codes,” in _Data Compression Conference, 2004. Proceedings. DCC 2004_. IEEE, 2004, pp. 312–321.
  * [14] M. Hein, W. Dür, J. Eisert, R. Raussendorf, M. Nest, and H.-J. Briegel, “Entanglement in graph states and its applications,” _arXiv preprint quant-ph/0602096_ , 2006.
  * [15] D. Gottesman, _Stabilizer codes and quantum error correction_. California Institute of Technology, 1997.
  * [16] D. Schlingemann, “Stabilizer codes can be realized as graph codes,” _arXiv preprint quant-ph/0111080_ , 2001.
  * [17] M. Grassl, A. Klappenecker, and M. Rotteler, “Graphs, quadratic forms, and quantum codes,” in _Proceedings IEEE International Symposium on Information Theory,_. IEEE, 2002, p. 45.
  * [18] K. Goodenough, S. de Bone, V. L. Addala, S. Krastanov, S. Jansen, D. Gijswijt, and D. Elkouss, “Near-term $n$ to $k$ distillation protocols using graph codes,” _arXiv preprint arXiv:2303.11465_ , 2023.
  * [19] M. Van den Nest, J. Dehaene, and B. De Moor, “Graphical description of the action of local clifford transformations on graph states,” _Physical Review A_ , vol. 69, no. 2, p. 022316, 2004.
  * [20] M. Englbrecht, T. Kraft, and B. Kraus, “Transformations of stabilizer states in quantum networks,” _Quantum_ , vol. 6, p. 846, 2022.
  * [21] A. R. Calderbank, E. M. Rains, P. M. Shor, and N. J. Sloane, “Quantum error correction via codes over gf (4),” _IEEE Transactions on Information Theory_ , vol. 44, no. 4, pp. 1369–1387, 1998.
  * [22] K. Pommerening, “Fourier analysis of boolean maps–a tutorial,” _Johannes-Gutenberg-Universitaet working paper_ , 2005.
  * [23] D. Gottesman, “Class of quantum error-correcting codes saturating the quantum hamming bound,” _Physical Review A_ , vol. 54, no. 3, p. 1862, 1996.
  * [24] C. Cafaro, D. Markham, and P. van Loock, “Scheme for constructing graphs associated with stabilizer quantum codes,” _arXiv preprint arXiv:1407.2777_ , 2014.
  * [25] A. Sajjad, E. Kaur, K. Goodenough, D. Towsley, and S. Guha, “Lower bounds on bipartite entanglement in noisy graph states,” _arXiv preprint arXiv:2404.09014_ , 2024.
  * [26] R. Hill, _A first course in coding theory_. Oxford University Press, 1986.
  * [27] E. M. Rains, “Quantum weight enumerators,” _IEEE Transactions on Information Theory_ , vol. 44, no. 4, pp. 1388–1394, 1998.
  * [28] V. Chauhan and A. Sharma, “Hamming weight enumerators of multi-twisted codes with at most two non-zero constituents,” _Finite Fields and Their Applications_ , vol. 76, p. 101910, 2021.
  * [29] K. Goodenough, D. Elkouss, and S. Wehner, “Assessing the performance of quantum repeaters for all phase-insensitive gaussian bosonic channels,” _New Journal of Physics_ , vol. 18, no. 6, p. 063005, 2016.
  * [30] C. H. Bennett, I. Devetak, A. W. Harrow, P. W. Shor, and A. Winter, “The quantum reverse shannon theorem and resource tradeoffs for simulating quantum channels,” _IEEE Transactions on Information Theory_ , vol. 60, no. 5, pp. 2926–2959, 2014.
  * [31] D. Yang, K. Horodecki, M. Horodecki, P. Horodecki, J. Oppenheim, and W. Song, “Squashed entanglement for multipartite states and entanglement measures based on the mixed convex roof,” _IEEE Transactions on Information Theory_ , vol. 55, no. 7, pp. 3375–3387, 2009.
  * [32] S. Jansen, K. Goodenough, S. de Bone, D. Gijswijt, and D. Elkouss, “Enumerating all bilocal clifford distillation protocols through symmetry reduction,” _Quantum_ , vol. 6, p. 715, 2022.

##  Appendix A Proof of Lemma LABEL:lemma:injectivity

We give here a proof of Lemma 1. It is more convenient to work with the dual
$H^{\perp}$ instead of $H$ itself. Lemma 1 can then be rephrased as follows.

######  Lemma 3.

For every dual $H^{\perp}$ of a stabilizer group $H$ on a set of qubits $V$,
there exists a stabilizer group $\overline{H}$ of a stabilizer state on a set
of qubits $V^{\prime}\cup V$ such that $H=\overline{H}\backslash V^{\prime}$.

###### Proof.

Note that $H^{\perp}$ can always be chosen to have a generating set of the
form
$\\{x_{1},x_{2},\ldots,x_{k},x_{k+1},\ldots,x_{n},z_{1},z_{2}\ldots,z_{k}\\}$,
such that $\\{x_{k+1},x_{k+2},\ldots,x_{n}\\}$ generates $H$. Here, the labels
are chosen such that two elements anti-commute iff they are of the form
$x_{i}$ and $z_{j}$ and $i=j$. One way of seeing this is by choosing a
‘canonical’ stabilizer group [32] $F=\langle
Z_{k+1},Z_{k+2},\ldots,Z_{n}\rangle$, noting that $F^{\perp}=\langle
Z_{1},Z_{2},\ldots,Z_{k},Z_{k+1},\ldots
Z_{n},X_{1},X_{2},\ldots,X_{k}\rangle$, and that the symplectic group acts
transitively on the set of all stabilizer groups. An example is given by the
groups in Fig. 1, where $H/1=\langle YY\rangle=\langle x_{2}\rangle$ and
$\left(H/\right)^{\perp}=H\backslash 1=\langle XX,YY,ZX\rangle=\langle
x_{1},x_{2},z_{1}\rangle$.

We now construct a generating set for $\overline{H}$ from
$\\{x_{1},x_{2},\ldots,x_{k},x_{k+1},\ldots,x_{n},z_{1},z_{2}\ldots,z_{k}\\}$,
by mapping each element $x_{i}$ ($z_{i}$) to some $\overline{x}_{i}$
($\overline{z}_{i}$). Since $H=\langle x_{k+1},x_{k+2},\ldots,x_{n}\rangle$,
we require that $\overline{x}_{i}$ is the same as $x_{i}$, except with
identity operators on the $k$ new qubits. For our example, we see that
$\overline{x}_{2}=IYY$.

For $\overline{x}_{i}$ with $1\leq i\leq k$, we attach a single $X$ operator
to the $i$’th new entry and identity everywhere else. We do the same for
$\overline{z}_{i}$ and $1\leq i\leq k$, but where we attach a single $Z$
operator to the $i$’th new entry instead of an $X$. The new $\overline{x}_{i}$
and $\overline{z}_{i}$ are independent and commute pairwise. Furthermore, the
group generated by the $\overline{x}_{i}$ and $\overline{z}_{i}$ has size
$2^{n+k}$, and each of its elements has length $n+k$. This implies that the
group generated by the $\overline{x}_{i}$ and $\overline{z}_{i}$ forms the
stabilizer group of a state. Finally, by construction it is clear they
generate a group that under deletion yields $H$.

For our example, we find that $\overline{x}_{1}=XXX$ and
$\overline{z}_{1}=ZZX$, which yields the stabilizer group of the graph state
$\ket{K_{3}}$. Note that a different choice of $x_{1},x_{2},z_{1}$ would have
yielded a different stabilizer group $H$. ∎


Performance Evaluations of Noisy Approximate Quantum Fourier Arithmetic

Robert A.M. Basili

Department of Mathematics, Iowa State University, Ames, IA 50011, USA

Department of Physics and Astronomy, Iowa State University, Ames, IA 50011, USA

Wenyang Qian

Department of Mathematics, Iowa State University, Ames, IA 50011, USA

Department of Physics and Astronomy, Iowa State University, Ames, IA 50011, USA

Shuo Tang

Department of Physics and Astronomy, Iowa State University, Ames, IA 50011, USA

Austin M. Castellino

Liberal Arts and Sciences Online, Iowa State University, Ames, IA 50011, USA

Mary Eshaghian-Wilner

Department of Mathematics, Iowa State University, Ames, IA 50011, USA

James P. Vary

Department of Physics and Astronomy, Iowa State University, Ames, IA 50011, USA

Glenn Luecke

Department of Mathematics, Iowa State University, Ames, IA 50011, USA

Ashfaq Khokhar

Department of Electrical and Computer Engineering, Iowa State University, Ames, IA 50011, USA

The Quantum Fourier Transform (QFT) grants competitive advantages, especially in resource usage and circuit approximation, for performing arithmetic operations on quantum computers, and offers a potential route towards a numerical quantum-computational paradigm. In this paper, we utilize efficient techniques to implement QFT-based integer addition and multiplications. These operations are fundamental to various quantum applications including Shor's algorithm, weighted sum optimization problems in data processing and machine learning, and quantum algorithms requiring inner products.

We carry out performance evaluations of these implementations based on IBM's superconducting qubit architecture using different compatible noise models. We isolate the sensitivity of the component quantum circuits on both one-/two-qubit gate error rates, and the number of the arithmetic operands' superposed integer states. We analyze performance, and identify the most effective approximation depths for quantum add and quantum multiply within the given context. We observe significant dependency of the optimal approximation depth on the degree of machine noise and the number of superposed states in certain performance regimes.

Finally, we elaborate on the algorithmic challenges - relevant to signed, unsigned, modular and non-modular versions - that could also be applied to current implementations of QFT-based subtraction, division, exponentiation, and their potential tensor extensions. We analyze performance trends in our results and speculate on possible future development within this computational paradigm.

§ INTRODUCTION

Since its proposal in 1994, the development of Shor's Algorithm [16] for factoring numbers in polynomial time has drawn intense interest in quantum computing, and recent technological leaps have quelled many of the doubts around its practical feasibility. While many challenges must be overcome before fault-tolerant quantum computing becomes remotely possible, the full range of cases where quantum advantage might be achieved remains largely speculative.

Presently, problem-solving techniques in quantum computing on Noisy Intermediate-Scale Quantum (NISQ) devices are generally considered within the context of a computational basis of qubits acted upon by quantum logic circuits [13]. In this paradigm, one generally maps a space of possible solutions to bit strings, and uses unitary operations (abstracted as quantum logic circuits) to operate on them. The mapping itself may be in some sense arbitrary, but practically must be designed to utilize machine-efficient unitaries.

However, just as the problem-solving paradigms used in classical computing historically advanced beyond binary representations as resources became more plentiful and reliable, the potential roles of quantum and/or quantum-classical hybrid data structures remain largely unknown. While this larger question extends beyond the scope of this work, we conduct these calculations in part as progenitorial steps towards the potential realization of such a numerical quantum-computational paradigm. For more immediate purposes, we also seek to elucidate practical, near-term limitations of current quantum devices, explore the effectiveness of a class of approximate circuits, and garner insight on what degree of that approximation is optimal for a given regime of machine performance.

Specifically, we consider quantum arithmetic performed with the Quantum Fourier Transform (QFT) and approximate QFT (AQFT).
The QFT, a phase-estimation algorithm, is the source of speed-up in Shor's algorithm, and provides several benefits for enabling quantum arithmetic. The approximate QFT improves the algorithm's performance and fidelity on noisy machines by removing gates whose impact on fidelity is less than the noise their inclusion imposes. Beyond quantum arithmetic's role in Shor's algorithm, its unique advantage of allowing many operations in parallel presents potential opportunities for a host of problems in data processing, machine learning, and more [9].

Although the anticipated utility of quantum arithmetic has given rise to many theoretical implementations and provided great incentive to explore its usage, effectively gauging an implementation's performance and identifying sources of error remains a significant obstacle. Barring recent years, considerations of algorithm performance remained fairly limited beyond its theoretical discussion [4]. Further, despite recent access to NISQ hardware, the small number of qubits, multiple sources of noise, and the relatively large circuit sizes of quantum arithmetic, have made progress in studying performance extremely limited. Ref. [11] provides performance results of quantum addition of up to 2-bit integers on the IBM Quantum superconducting-qubit testbed, and observes extremely limited fidelity with current hardware. While not specific to arithmetic, Ref. [10] provides a robust breakdown of various factors affecting a gate-based algorithm, including state preparation, oracle, connectivity, circuit rewriting, transpiling, and readout, and designed a calibration matrix to quantitatively evaluate the quantum error.

While the technology will need to improve significantly before quantum arithmetic can be examined directly in much depth, the study of quantum noise in current NISQ hardware has allowed rapid advancement in the study of quantum noise and the development of tunable noise models. These models offer the unique opportunity to garner insight into the implementation and performance of quantum arithmetic algorithms by modeling the isolated impact of different sources of noise. In this work, we simulate the dependency of quantum Fourier Addition (QFA) and Quantum Fourier Multiplication (QFM) on one- and two-qubit (1q- and 2q-) gate error rates, on approximation depth in the QFT, and on the number of superposed integer states involved in the operands (which we will refer to as a qinteger's order of superposition). We use noise models designed to reflect the current performance of IBM superconducting quantum computers (though with qubit counts and connectivity not currently available). We include perfect, noise-free simulations as a point of comparison to differentiate the noise introduced by the approximate QFT. The isolation of other sources of error, such as thermal relaxation and qubit measurement, their simultaneous simulation with 1q-/2q- gate errors, as well as the impact of error mitigation and extrapolation from integers to real numbers, are deferred to a future work. In this fashion, the current work reflects a preliminary effort to help assess the practical challenges that must be overcome before a quantum numerical paradigm can be realistically explored.
Finally, though not discussed, modular and non-modular forms of QFT-based quantum integer subtraction, division, exponentiation, and extensions to vector, matrix, and other tensor operations, rely on slight alterations to the same underlying algorithm, and, consequently, many of the considerations discussed here apply to them as well [6, 1, 14, 2, 17]. These results may also provide insight regarding the QFT, AQFT, and quantum algorithms that rely upon them.

This paper is organized as follows. Sec. <ref> briefly describes our implementation of the AQFT. In Sec. <ref> we illustrate Quantum Fourier Addition and Quantum Fourier multiplication, and describe our implementation. In Sec. <ref>, we provide specific details on the generation, collection, and presentation of performance data considered in this study, and discuss their interpretation.

Finally Sec. <ref> summarizes this work and discusses its future development.

§ PHASE-ENCODING AND THE QUANTUM FOURIER TRANSFORM

We begin by specifying the quantum integers (qintegers) discussed in this work as a mathematical construct, and how we encode them as a quantum data structure. We consider the space of integer states $\ket{i}$ with $i\in \mathbb{Z}$. A qinteger $y$ is thus defined as a superposition of integer states,

$$\overset{k}{\underset{i}{\sum}}p_{i}^{2} = 1$$

is the sum of all integer probabilities, $p_i^2$, and must add to unity. We refer to a superposition of $j$ unique integers with $j$ respective nonzero probability amplitudes as an order-$j$ qinteger.

The representation of qintegers can be achieved by several means, and their optimal implementation depends on the computational model required [7].

For our purposes, we constrain the current discussion to dynamic qintegers - that is, qintegers whose values can be updated by methods without collapsing superposition - realized on quantum registers of $n$ qubits. We encode qintegers in two's complement, though the results of this work may be extended to fixed point binary representations of numbers in general. The maximum order of superposition for an $n$-qubit qinteger is therefore limited by the size of the register's computational basis, $N=2^n$, or an order-$N$ qinteger.

We facilitate our discussion using the quantum circuit paradigm as our starting point.

Similar to how one may encode integers classically in the computational basis as bitstrings, quantum superposition enables one to encode numbers in the relative phases of qubits. Since linear phase shifts are a fundamental operation of most quantum computers, this encoding is particularly convenient for performing basic arithmetic operations.

We refer to this basis of relative phases as the Quantum Fourier Basis (QFB). The QFT is an $\mathcal{O}(n\log_2n)$ quantum algorithm that performs a Fourier Transform of quantum mechanical amplitudes, and serves to transform numbers encoded in the computational basis to the QFB.

Whereas the discrete Fourier Transform over classical fields involves an expansion that mixes vectors of complex numbers, the QFT involves the expansion of the computational basis $\ket{y}=\ket{0},\ \ket{1}, \ldots ,\ \ket{N-1}$ into mixtures of QFB states $\ket{k}=\ket{\phi(0)},\ \ket{\phi(1)}, \ldots ,\ \ket{\phi(N-1)}$ (or vice-versa), as

\begin{equation}
\mathcal{QFT} \ket{y} = \frac{1}{\sqrt{N}}\sum_{k=0}^{N-1} e^{\imag 2\pi yk/N} \ket{k}
\end{equation}

for initial integer state $\ket{y}$ encoded in the computational basis with $n$ qubits and $N=2^n$ unique states. The corresponding inverse QFT is defined

\begin{equation}
\mathcal{QFT}^{-1} \ket{k} = \frac{1}{\sqrt{N}}\sum_{y=0}^{N-1} e^{-\imag 2\pi yk/N} \ket{y}.
\end{equation}

When we apply the QFT to the state $\ket{y} = \ket{y_1} \otimes \ket{y_2} \otimes \ldots \otimes \ket{y_n}$ (or as a binary string $y = ``y_n y_{n-1}  \ldots y_1"$ such that $y = y_1 2^0 + y_2 2^1 + \ldots + y_n 2^{n-1}$), one obtains the result:

\begin{equation}
\label{eq_QFT2}
\begin{aligned}
\mathcal{QFT} \ket{y} = & \frac{1}{2^{n/2}}\bigotimes_{q=1}^{n}\left(\ket{0}+ e^{\imag 2\pi
%[0.y_q y_{q-1} \ldots y_1]
\left(\sum_{k=1}^{q} y_k/2^{q-k+1}\right)
} \ket{1}\right)_q \\
= & \frac{1}{2^{n/2}}\bigotimes_{q=1}^{n}\left(\ket{0}+ e^{\imag 2\pi
} \ket{1}\right)_q,
\end{aligned}
\end{equation}

where the parenthetical subscript on the right-hand side denotes the $q$th qubit's state, and
we rewrite the summation in the exponent using the binary-fraction shorthand

$[0.y]_{i,j}=0.y_i y_{i-1} \ldots y_{j}= y_i/2+y_{i-1}/4 + \cdots + y_j/2^{i-j+1}$ for convenience.

If we consider from this the action of the QFT on each qubit, one notices that, after applying the QFT, the first qubit (which originally had the state $\ket{y_1}$) will possess a state where the phase summation on the right-hand side of Eq. (<ref>) reduces to only one term, $[0.y]_{1,1}=y_1/2$. Notably, this means the first qubit's final state only depends on its own initial state. Meanwhile, the $y_2$ qubit will have two terms, $[0.y]_{2,1}=y_2/2+y_1/4$, for its sum of phases, and thus depends on the initial states of both itself and the first qubit. Finally, the $n$th qubit's final state will involve a sum of n terms, and depends on the initial states of all n qubits. If we consider each term of these summations as a single phase rotation being controlled by a single qubit, the first qubit requires one such rotation, the second requires two, and so on. Further, the first rotation on a given qubit is controlled by itself, while each subsequent rotation is controlled by each qubit that comes before it.

To implement the QFT described by Eq. (<ref>) as a quantum circuit, we must construct the Fourier Transform in terms of unitaries. We therefore introduce the two-qubit controlled rotation phase gate $R_{l}$ and one-qubit Hadamard gate $H$ with which we shall construct the circuit. Using the basis ordering common to most textbooks for our matrix representation of quantum operators (sometimes called big-endian convention), we may write the unitary transformations

\begin{equation}
R_{l} =\begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & 1 & 0 \\
0 & 0 & 0 & e^{\frac{\imag 2\pi }{2^l}}
\end{bmatrix},
H =\frac{1}{\sqrt{2}}\begin{bmatrix}
1 & 1 \\
1 & -1
\end{bmatrix},
\end{equation}

where it is understood the dimensions span the corresponding Hilbert space specific to the given qubit(s) that the operator acts upon. Both gates can be efficiently constructed with only one or two gates of the universal gate set used by current IBM superconducting quantum [5].

To perform the QFT on a single $n$-qubit qinteger, we first apply the Hadamard gate to each qubit, followed by consecutive controlled-$R_{l}$ gates as shown in Fig. <ref>. Repeating the procedure for all the qubits in the qinteger's register and including the normalization factor of $1/\sqrt{2}$, we obtain the qubit state shown on the right in Eq. (<ref>).

\[
\begin{array}{c}
\Qcircuit @C=0.8em @R=1.0em {
\lstick{\ket{y_{n}}}   & \gate{H} & \gate{R_{2}} & \qw   & \cdots &    &
\gate{R_{d}}  &   \gatered{\color{red}R_{d+1}} & \qw     & \cdots &    &
\gatered{\color{red}R_{n}}   &   \qw    & \qw &   \cdots &   &
\qw                          & \qw                          &
\qw & \cdots  &  & \qw      & \qw          & \qw     &
\rstick{\ket{\phi_n(y)} }  \qw        \\
\lstick{\ket{y_{n-1}}}  & \qw     & \ctrl{-1}    & \qw   & \cdots &    &
\qw             &    \qw                     & \qw     & \cdots &      &
\qw                          & \gate{H} & \qw &   \cdots &   &
\gatered{\color{red}R_{n-2}} & \gatered{\color{red}R_{n-1}} &
\qw & \cdots  &  & \qw      & \qw          & \qw     &
\rstick{\ket{\phi_{n-1}(y)}}   \qw       \\
\lstick{\vdots }        &         &              &       & \ddots &    &
&                            &         & \ddots  &     &
&          &     &   \ddots &   &
&                              &
& \ddots  &  &          &              &         &
\rstick{\vdots}\\
\\
\lstick{\ket{y_{n-d}}}  &   \qw   &   \qw        &   \qw & \cdots &    &
\ctrl{-4}       &  \qw                       & \qw     & \cdots  &      &
\qw                          & \qw      & \qw &  \cdots &   &
\qw                          & \qw                         &
\qw & \cdots  &  & \qw      & \qw          & \qw     &
\rstick{\ket{\phi_{n-d}(y)} }  \qw        \\
\lstick{\ket{y_{n-d-1}}}  &   \qw   &   \qw      &   \qw & \cdots &    &
\qw             &  \ctrlred{-5}               & \qw     & \cdots  &     &
\qw                          & \qw      & \qw &  \cdots &   &
\qw                          & \qw                          &
\qw & \cdots  &  & \qw      & \qw          & \qw     &
\rstick{\ket{\phi_{n-d-1}(y)} }  \qw        \\
\lstick{\vdots }        &         &              &       & \vdots &    &
&                            &         & \ddots  &     &
&          &     &   \ddots &   &
&                              &
& \ddots  &  &          &              &         &
\rstick{\vdots}\\
\\
\lstick{\ket{y_{2}}}    &   \qw   &   \qw        &   \qw & \cdots &    &
\qw             & \qw                        & \qw     &  \cdots &     &
\qw                          & \qw      & \qw &   \cdots &   &
\ctrlred{-7}                   & \qw                          &
\qw & \cdots  &  & \gate{H} & \gate{R_2}   & \qw     &
\rstick{\ket{\phi_2(y)} } \qw  \\
\lstick{\ket{y_{1}}}    &   \qw   &   \qw        &   \qw & \cdots &    &
\qw             & \qw                        & \qw     &  \cdots &     &
\ctrlred{-9}                 & \qw      & \qw &   \cdots &   &
\qw                          & \ctrlred{-8}                  &
\qw & \cdots  &  & \qw      & \ctrl{-1}   & \gate{H} &
\rstick{\ket{\phi_1(y)} } \qw
\end{array}
\]

Generalized quantum circuit for the QFT. Gates removed when performing the AQFT at approximation depth $d$ are drawn in red.

When a large number of qubits are involved, the conditional rotation $R_{l \rightarrow \infty}\rightarrow I$ of the QFT approaches the identity. On one hand, encoding in the QFB therefore requires that the accuracy of the phase shift performed by the physical quantum computer increases exponentially with $n$ to ensure addition via phase shifts remains truly linear at all scales. On the other hand, one rarely requires such accuracy for phase rotations between bits of sufficiently different binary order in most practical computations. This enables approximation that is particularly useful when working with noisy quantum devices, which is a primary motivation of the AQFT.

In the AQFT, we define a depth, $d$, which serves as an upper limit for the number of conditional rotation gates  applied to each qubit in the QFT circuit. We illustrate this in Fig. <ref>, where gates present in the QFT but removed in the AQFT are marked in red. In comparison to Eq. (<ref>), the AQFT takes the form

\begin{equation}
\label{eq_AQFT}
\mathcal{AQFT} \ket{y} = \frac{1}{2^{n/2}}\bigotimes_{q=1}^{n}\left(\ket{0}+ e^{\imag 2\pi
} \ket{1}\right)_q,
\end{equation}

While the QFT requires $n(n+1)/2$ operations and possesses a time complexity of $O(n^2)$, the AQFT at depth d reduces this to $(2n-d)(d-1)/2$. As derived by Barenco et. al. [3], in the presence of decoherence and sufficiently large n, one expects the optimal depth of the AQFT to approximately approach $d\rightarrow \log_2 n$, requiring $O(n\log_2 n)$ operations. While the results in Section <ref> support this, we do observe instances where, for a given operation, the optimal depth deviates from this expectation.

§ QUANTUM ARITHMETIC OPERATIONS

We now consider two operand qintegers, $\ket{x}$ and $\ket{y}$ of $n$ and $m$ qubits, respectively. We discuss our implementation of Quantum Fourier Addition (QFA) first, as it is required for our implementation of Quantum Fourier Multiplication (QFM).

The first step of QFA is to transform one of the addends into the Fourier basis, with the QFT, as discussed in Sec. <ref> (we will choose $y$). The addition step can then be performed through a sequence of conditional rotations that add the phase-encoded magnitude of $\ket{x}$ to $\ket{\phi(y)}$. The process is completed by applying the inverse QFT to $\ket{\phi(X+y)}$, to return that register to the computational basis.
Throughout this process, $\ket{x}$ remains in the computational basis.

Whereas, for the QFT, the conditional rotations on a given qubit (i.e. $y_i$) are controlled entirely by the other qubits defining $\ket{y}$, the rotations performed in the QFA circuit are controlled by the qubits of $\ket{x}$ following

\begin{align}
\mathcal{QFA}\frac{1}{\sqrt{N}}\sum_{k=0}^{N-1} e^{\imag 2 \pi y k/N}\ket{x} \ket{k} =
\frac{1}{\sqrt{N}}\sum_{k=0}^{N-1}e^{\imag 2 \pi x k/N} e^{\imag 2 \pi y k/N}\ket{x} \ket{k}.
\end{align}

The quantum circuit for the QFA addition step is shown in Fig. <ref>. Just like with the QFT, the deeper rotations of the addition step approach the identity, and it has been speculated that a similar cutoff on depth in the add step may improve performance in the presence of noise [6]. However, unlike with the AQFT, where this approximation impacts the linearity of the transform domain, a similar cutoff in the addition step more directly impacts the phase shifts being applied. This, in addition to the fact that the same cutoff in the addition step will remove half as many gates overall in the QFA, leads us to expect the benefits of such an approximation will be less apparent than the AQFT (particularly at lower $n$). Thus, we have opted to consider the AQFT first, and leave the consideration of an approximate addition step for a future work.

@C=0.8em @R=1.0em
|x_n⟩       6                 ⋯                            7                                                                        |x_n⟩

|x_n-1⟩             5             ⋯                              6                                                            |x_n-1⟩

⋮                                ⋱                                          ⋱                                                    ⋮

|x_2⟩                                       2                                                 3                   6                   |x_2⟩

|x_1⟩                                          1                                                 2                5            6          |x_1⟩

|ϕ_n+1(y)⟩        R_2          R_3             ⋯             R_n         R_n+1                                                                                |ϕ_n+1(x+y)⟩

|ϕ_n(y)⟩                                                 R_1       R_2          ⋯          R_n-1        R_n                                |ϕ_n(x+y)⟩

⋮                                                                         ⋮                                                ⋮

|ϕ_2(y)⟩                                                                                R_1     R_2                |ϕ_2(x+y)⟩

|ϕ_1(y)⟩                                                                                R_1         |ϕ_1(x+y)⟩

The generalized addition step of the QFA circuit, being applied in the transform domain.

Once the addition step is complete and
$\ket{\phi(y)}\rightarrow \ket{\phi(x+y)}$,
one recovers the sum by transforming the output back to the computational basis using the inverse QFT:

\begin{equation}
\begin{aligned}
\mathcal{QFT}^{-1}\frac{1}{\sqrt{N}}\sum_{k=0}^{N-1}e^{\imag 2 \pi x k/N} e^{\imag 2 \pi y k/N}\ket{x} \ket{k}
& = \frac{1}{N} \sum_{k,l=0}^{N-1} e^{\imag 2\pi (x+y)k /N}e^{ -\imag 2\pi kl/N} \ket{x}\ket{l} \\
& = \ket{x} \ket{(x+y) \mod N}.
\end{aligned}
\end{equation}

Applying the QFT, addition step, and inverse QFT together, we denote the full QFA circuit

\[
\begin{array}{c}
\Qcircuit @C=0.8em @R=1.0em {
\lstick{\ket{x}} & \qw {/} & \ustick{n} \qw & \qw & \ctrl{2} & \rstick{\ket{x}} \qw & & &
\lstick{\ket{x}} & \qw {/} & \ustick{n} \qw & \qw & \qw & \ctrl{2} & \qw & \rstick{\ket{x}} \qw \\
&    &  &     &   &                    & \push{\rule{2.9em}{0em}=\rule{1.9em}{0em}} & & & & & &\\
\lstick{\ket{y}} & {/} \qw & \ustick{n+1} \qw & \qw & \gate{QFA} & \rstick{\ket{x+y}} \qw & & &
\lstick{\ket{y}}   & \qw {/} & \ustick{n+1} \qw & \qw & \gate{QFT} & \gate{add} & \gate{QFT^{-1}} & \rstick{\ket{x+y}} \qw
\end{array}
\]

To perform non-modular addition, one simply ensures the register being updated ($\ket{y}$ in our case) is large enough to avoid overflow by having $m=n+1$  or more qubits (for $m > n+1$, the QFA process only involves the first $n+1$ qubits of $y$). Strategies for modular addition of signed and unsigned integers with the QFT have also been developed [14, 17].

A few different approaches for quantum multiplication with the QFT have been proposed [1, 17]. For the purposes of this study, we implement a QFM approach similar to the weighted-sum strategy for unsigned integers presented by Ruiz-Perez [14], with only a few marginal differences. Unlike the QFA described above, in which one of the addends is updated, this approach preserves both multiplicand states, and instead updates a separate product register (which is generally initialized to zero). To avoid any potential overflow, the product register must be at least as large as the combined sizes of the two multiplicand registers. The process involves applying the QFA iteratively on a varying subset of the product register, while being controlled by the multiplicand's qubits.

In order to define the QFM circuit explicitly, we must first introduce the controlled-controlled-phase rotation gate, $cR_l$, and controlled-Hadamard gate, $cH$, which we will use to define the controlled QFT (cQFT) and controlled-addition step (cadd) required by the QFM.

\begin{equation}
cR_{l} =\begin{bmatrix}
1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\
0 & 0 & 0 & 0 & 0 & 0 & 0 & e^{\frac{\imag 2\pi }{2^l}}
\end{bmatrix},
cH =\begin{bmatrix}
1 & 0 & 0 & 0 \\
0 & 1 & 0 & 0 \\
0 & 0 & \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\
0 & 0 & \frac{1}{\sqrt{2}} & -\frac{1}{\sqrt{2}}
\end{bmatrix}.
\end{equation}

Replacing the $R_l$ and $H$ gates with $cR_l$ and $cH$ in Figs. <ref> & <ref>, we define the cQFT, cadd, and cQFT$^{-1}$ circuits just as we did before, but now with one additional control qubit, $c$, controlling every gate of the process. We denote the controlled QFA (cQFA) as

\[
\begin{array}{c}
\Qcircuit @C=0.8em @R=1.0em {
\lstick{\ket{c}} & \qw & \qw & \qw & \ctrl{1} & \rstick{\ket{c}} \qw & & &
\lstick{\ket{c}} & \qw & \qw  & \qw & \ctrl{2} & \ctrl{1} & \ctrl{2} & \rstick{\ket{c}} \qw \\
\lstick{\ket{x}} & \qw {/} & \ustick{n} \qw & \qw & \ctrl{1} & \rstick{\ket{x}} \qw & \push{\rule{2.9em}{0em}=\rule{1.9em}{0em}} & &
\lstick{\ket{x}} & \qw {/} & \ustick{n} \qw & \qw & \qw & \ctrl{1} & \qw & \rstick{\ket{x}} \qw \\
%        &    &  &     &   &                    &  & & & & & &\\
\lstick{\ket{y}} & {/} \qw & \ustick{n+1} \qw & \qw & \gate{cQFA} & \rstick{\ket{x+y}} \qw & & &
\lstick{\ket{y}}   & \qw {/} & \ustick{n+1} \qw & \qw & \gate{cQFT} & \gate{cadd} & \gate{cQFT^{-1}} & \rstick{\ket{x+y}} \qw
\end{array}
\]

The QFM circuit of this process is provided in Fig. <ref>, with product register $\ket{z}$ of $n+m$ qubits. Here, the qubits of $\ket{x}$ take the role of the additional control qubit. The process is perhaps easiest to understand when considering the classical case, where the qintegers are each in a single integer state. In that case, the $i$th cQFA step adds $x_i2^{i-1}y$ to the product register, where $x_i$ is 0 or 1, and $y$ is a single integer.

\[
\begin{array}{c}
\Qcircuit @C=0.8em @R=1.0em {
\lstick{\ket{x_{n}}} & \qw  &  \qw & \qw &   \qw & \qw & \cdots&    &   \ctrl{5}   &   \qw &   \rstick{\ket{x_n}}  \qw        \\
\lstick{\vdots }  &   &   &   &  & & \iddots &   &    &   &  \rstick{\vdots}  \\
\\
\lstick{\ket{x_{2}}}  &   \qw & \qw &   \qw      & \ctrl{2} & \qw & \qw & \qw    &  \qw &  \qw &  \rstick{\ket{x_{2}}}\qw
\\
\lstick{\ket{x_{1}}}  &   \qw &   \qw & \ctrl{1} &   \qw  & \qw & \qw &  \qw &   \qw &   \qw &    \rstick{\ket{x_{1}}} \qw
\\
\lstick{\ket{y}}  &    {/} \qw & \ustick{m} \qw & \ctrl{8} & \ctrl{7} &\qw &  \cdots &  &   \ctrl{1} & \qw   &    \rstick{\ket{y}} \qw
\\
\lstick{\ket{z_{n+m}}}   &  \qw    &   \qw   &   \qw & \qw & \qw &  \cdots&    & \multigate{3}{cQFA} &   \qw &   \rstick{\ket{z_{n+m}}}  \qw      \\
\lstick{\vdots }  &   &   &   &   &   & \vdots & & &    & \rstick{\vdots}  \\
\\
\lstick{\ket{z_{n}}}   &  \qw    &   \qw   &   \qw & \qw  & \qw & \cdots&    &  \ghost{cQFA}   &   \qw &   \rstick{\ket{z_{n}}}  \qw      \\
\lstick{\vdots}  &   &   &  &   &   & \iddots & & &    & \rstick{\vdots}  \\
\\
\lstick{\ket{z_{m+2}}}   & \qw     &   \qw   &   \qw & \multigate{4}{cQFA} & \qw & \cdots&   &   \qw & \qw &  \rstick{\ket{z_{m+2}}}  \qw      \\
\lstick{\ket{z_{m+1}}}  &  \qw    &   \qw  & \multigate{4}{cQFA} & \ghost{cQFA} & \qw &   \cdots & &    \qw &   \qw  & \rstick{\ket{z_{m+1}}}\qw       \\
\lstick{\vdots }  &   &   &  &  &   & \vdots & & &    & \rstick{\vdots}  \\
\\
\lstick{\ket{z_2}}    &   \qw &   \qw & \ghost{cQFA} & \ghost{cQFA} &   \qw & \cdots &     &  \qw &  \qw   &  \rstick{\ket{z_2}}\qw  \\
\lstick{\ket{z_1}}  &   \qw &   \qw & \ghost{cQFA} & \qw &  \qw  &  \cdots  & &   \qw &   \qw    &  \rstick{\ket{z_1}} \qw
\end{array}
\]

The generalized QFM circuit, drawn such that $m<n-1$. If $n=m$, then $\ket{z_n} = \ket{z_{m+1}}$ and the diagram shifts accordingly, and further shifts if $m>n$.

Before we turn our attention to the results of this study, one might note that in quantum addition, so long as $\ket{x}$ is in a single integer state, one could instead store it purely on classical bits, rather than a separate register of qubits as discussed above. In that case, the resulting addition circuit would change dynamically based on the single integer being added, where the controlled rotation gates would be replaced by 1-qubit rotation gates acting on $\ket{y}$. This would result in shorter and less complex circuits that serve to boost all superposed integer states by a single integer value. Naturally, a similar option exists in quantum multiplication for applying a constant factor across all states. While worth acknowledging as a potential interest, we shall maintain our current focus on cases where both operands are stored on quantum registers and allow superposition.

§ RESULTS AND DISCUSSION

We present performance results of simulated quantum Fourier addition and multiplication for varying approximation depths, 1q-/2q-gate error rates, and operand's order of superposition. Fig. <ref> presents results from addition between two $n=8$ qintegers, and Fig. <ref> presents the results of multiplication between two $n=4$ qintegers.

We use the same organizational structure in both figures. The left column presents results with varying 1q-gate error rate, while the right column shows results with varying 2q-gate error rate. The top row shows results for operations where both operands are order-1 qintegers (henceforth referred to as a 1:1 operation). The middle row reflects results where one operand is order-1 and the other is order-2 (a 1:2 operation; in the case of addition, the order-2 addend is always stored on the qubit register that is being updated). The bottom row reflects results where both operands are order-2 qintegers (2:2 operation). For all simulated operations with superposed integer states, the probability amplitude is evenly distributed between each state. In addition, for each considered case of superposition and arithmetic operation (i.e. for each row of each figure), the same unique, randomly-generated set of operand states are used for calculating results of both varying 1q-gate error and varying 2q-gate error.

Results in the figures are clustered along the horizontal axis based on their gate error rate. All points within the same cluster correspond to the same error rate, and are only shifted apart horizontally for visibility. The alignment of the center-most point of a cluster on the x-axis reflects the gate error rate used for all calculations in that cluster (for instance, all points in the leftmost cluster correspond to results simulated with a 0.2% 1q-gate error rate, then 0.3%, for the next cluster, and so on). Results are color-coded based on the approximation depth used in those calculations and correspond to the legend in panel (a) of the respective figure. `Full' designates that the full QFT circuit is performed in those simulations.

We employ a simple success metric for each unique arithmetic operation using quantum state tomography, similar to that of Ref. [11]. Each point in each figure marks the overall success rate in percentage (vertical axis) of 200 (or more) instances of the arithmetic operation on a random, unique choice of qintegers simulated at the given 1q-/2q-gate error rate, operand superposition, and AQFT approximation depth. For each instance, the simulated AQFA/AQFM circuit was repeated 2048 times (referred to as `shots'), and the outputs were tabulated. Instances were considered `successful' when the binary outputs with the highest frequency matched those anticipated based on the input values. In cases where multiple `correct' outputs were expected (due to superposed inputs), instances were deemed unsuccessful if any incorrect output possessed more counts than any one of the correct outputs. All results meeting this criterion were classified `successful', regardless of any significant inequalities in the distribution between the correct outputs (though very few such cases were observed).

In addition to each point, an associated pair of error bars are included to indicate the average ratio of correct to incorrect outputs observed for those results. In each instance, the minimum difference in counts between any single correct and incorrect output was recorded, and the standard deviation, $\sigma$, of these differences was calculated using all instances of the associated point. The lower/upper error bars therefore represent the number of correct/incorrect instances that would have been incorrect/correct within one $\sigma$, respectively. Narrow error bars reflect large differences between correct and incorrect output counts, while a relatively smaller error bar below/above the point reflects cases where many instances were on the verge of being correct/incorrect.

For each figure, we include either 1q-gate or 2q-gate error rates (denoted $P^{err}_{1q}$ and $P^{err}_{2q}$, respectively, and varied on the x-axis) in our noise model, and do not include any other gate errors, reset errors, measurement errors, or noise associated with qubit-layout and/or swap-gates (i.e., we consider an idealized layout with complete qubit connectivity). Results with no simulated noise are provided at the x-origin of each plot to help differentiate the impacts associated with the approximation depth, operand superposition, and gate error rates. The transparent, dashed, vertical lines at 0.2% in the 1q-gate error rate plots and at 1.0% in the 2q-gate error rate plots approximate the average reported performance of current IBM superconducting quantum computers [5, 12].

The construction and simulation of all circuits, noise models, and algorithms were implemnted using Qiskit 0.31.0 and python 3.7. For all model calculations, circuits are decomposed in terms of the universal gate set of current IBM superconducting quantum computers (i.e., Id, X, RZ, SX, and CX-gates) [5].

In all simulated arithmetic, the operands' qinteger states were initialized using the reverse decomposition algorithm of Ref. [15] implemented in Qiskit. No noise/errors of any kind were included during the initialization process, regardless of how many gates would have been required for the given states' initialization on a real machine. The 1q and 2q gate counts of the simulated circuits (excluding gates associated with initialization and measurement) are tabulated in Table <ref>.

§.§ Discussion

With the details of the calculations specified, we now discuss our results. Beginning with the 1:1 addition results ((a) and (b) in Fig. <ref>), we see the outputs are largely insensitive to the examined regime of gate error rates. Besides a small number of cases where the AQFT depth is one, all the QFA operations consistently produced correct results, and the lack of error bars demonstrates none of these successes were within one standard deviation of failure. Even in the case of the $d=1$ calculations where the approximation is most significant and errors do occur, the number of errors show little to no dependency on the gate error rates, indicating the errors are primarily the result of the approximation rendering the encoding too non-linear for some of the additions. The optimal choice of approximation depth appears to be $d>1$ for these cases, though any differences between the larger depths aren't visible in this case.

Moving to the 1:2 QFA results and 2:2 QFA results ((c), (d), (e), and (f) in Fig. <ref>), we immediately see greater sensitivity to the gate error rates in this regime. This follows the general trend that, for the near future, quantum applications that rely on or converge towards heavier output (that is, output corresponding to fewer, more highly-correlated binary strings in the computational basis) will be a driving design factor for early quantum applications, due to the significant noise observed in current hardware. (For instance, since each of the four correct outputs of the 2:2 results ideally possesses $\textapprox25\%$ of the probability density, fluctuations from noise have a far greater impact.) We also notice that while dependence on the 2q-error rate disappears at higher values than that of the 1q-gate error rate in these calculations, the impact of the 1q-gate error rate in current machines appears to have already largely been overcome (at least for QFA at $n=8$), compared to the larger number of errors corresponding to the current hardware's 2q-gate error rates. This appears to support the general expectation that 2q-gate fidelity is one current bottleneck for the performance of applications on modern quantum hardware. However, both here and in the 2:2 QFA results, we see a slower improvement of our result quality with reduced 1q-gate error compared to reduced 2q-gate error rates. If this trend continues at lower error rates and larger $n$, the 1q-gate errors could overcome 2q-gate errors as a limiting factor for the QFA at high $n$. Determining whether this trend continues to hold will require further simulation and study.

Unlike the 1:1 QFA results, both the 1:2 and 2:2 QFA results provide much more insight regarding the optimal approximation depth. Even just considering only the reduction in error garnered by the AQFT in the presence of either 1q- or 2q-gate error, we generally see at least similar levels of performance to the full QFT for depths near $d=\log_2 n$, and frequently a slight improvement. One anticipates significantly more benefit on a real machine, where the AQFT's reduction in gate count will also mitigate errors associated with reset, measurement, qubit-connectivity, and other sources of noise. As surmised in [3], the quality of results do appear to be somewhat higher near $\log_2 n=3$. However, we observe significant variation in the optimal approximation depth between clusters in and between all four plots. Depths 2, 3 and 4 are the most common optima, though generally by relatively small margins. Even beyond the noise-free simulations, the AQFT at depth 1 generally produces significantly lower quality, supporting how, even at $n=8$, not going to too low an approximation depth is critical to maintaining performance when using the AQFT.

Looking now to the QFM results presented in Fig. <ref>, we observe several notable similarities and differences with those of the QFA. For instance, despite the smaller register sizes occupied by the operands, the much larger circuit sizes required by the QFM results in notably lower success rates than seen in the QFA, even for the 1:1 QFM results. We also observe even stronger examples than seen in the QFA results of the 2q-gate error rate being a major limiting factor for performing quantum arithmetic. At the same time, while less pronounced than it was in the QFA results, we also observe hints of a similar, more rapid improvement in result quality as the 2q-gate error rate decreases compared to decreased 1q-gate error rates.

The QFM results also possess some unique features regarding the impact of the AQFT. On one hand, an approximation depth of 1 appears to consistently have a negative impact on QFM performance at low gate error rates, much like what was seen in the QFA results. On the other hand, at higher gate error rates, the AQFT at the same depth consistently begins to outperform depths 2 and 3, in some cases by margins as large as 40%; a far larger improvement than any observed for the QFA.

Finally, we see a common shape throughout our results, involving a roughly linear trend of the success rate with gate error rate, between asymptotic tails on the left/right side roughly approaching 100%/0% success rates, respectively. This is common to sampling over Gaussian distributions, and reflects that the impact of gate errors on the arithmetic success rate follows a similar pattern. The width of the linear region reflects the width of a 'plateau' in the statistical distribution, meaning a smaller width corresponds to a sharper threshold for success. The width of this region in our QFA results is consistently far wider than the QFM results.

We also notice in the QFM results (as well as (c) and (e) of the QFA results) that this region grows narrower as we increase the number of superposed operand states. If we assume this trend continues, one expects that the gate fidelity required for highly entangled arithmetic will be a relatively sharp threshold. Like the 2-bit results of quantum addition seen in Ref. [11], with sufficiently high gate error rates and order of superposition, we consistently observe results with an accuracy around 0%. This reflects that length of the circuit and poor gate fidelity create too much noise to extract the solution without error mitigation and/or a more advanced success metric, such as evaluating the quantum state fidelity [8].

Arithmetic Circuit Gate Counts

1c|      5|c|QFA ($n=8$)     3|c|QFM ($n=4$)

$d^{*}$     1     2    3    4     $7^{**}$     1     2     $3^{**}$

1q     163     199     229    253     289     1032     1248     1464

2q     98     122     142     158     182     744     936     1128

9l$^*$AQFT approximation depth

9l$^{**}$This depth is equivalent to the full QFT for the given $n$.

§ CONCLUSIONS

In this study, we examined (via simulation) the dependency of QFA and QFM on one- and two-qubit gate error rates, approximation depth in the QFT, and operand's order of superposition. We utilized noise models to isolate sources of error and compared the results to perfect, noise-free simulations to differentiate noise inherent to the approximate QFT. In a broader sense, this work reflects an initial effort to better assess the practical challenges that must be overcome before a quantum numerical paradigm can be realistically explored.

The use of the AQFT proved very effective in both our QFA and QFM results, often generating little to no negative impacts, even in error-free simulation. In the presence of noise, results with the AQFT near the optimal approximation almost always produced higher quality results than those of the full QFT. However, even at low qubit count, $n$, we observed how going to too low an approximation depth has a severe negative impact on our result quality. Further, while a depth of $d=\log_2 n$ served as a reasonable heuristic, we observed significant variation on the optimal approximation depth between the orders of superposition, and even between changes in the gate error rates alone.

Our results support the expectation that 2q-gate error rates currently pose the greater obstacle for quantum arithmetic, though we also observed that our success rates improved much faster as the 2q-gate error rate falls than it does as the 1q-gate error rate falls. Determining whether this suggests 1q-gate errors will surpass 2q-gate errors as a limiting factor at high $n$ for the discussed arithmetic approaches requires further study.

As anticipated, we observed significant drops in performance as we increased the order of superposition, and that lower error rates significantly reduced this drop in performance. For instance, at the optimal depth, increasing 1:2 addition to 2:2 addition at $n=8$ resulted in over a 50% drop in accuracy at the current 2q-gate error rate of current IBM hardware (1%), but only incurred a 3% drop when simulated with the improved 2q-gate error rate of 0.7%. Consequently, the possibility of a quantum numerical computational paradigm will rely heavily on further improving current hardware.

This work sheds light on the current challenges and hardware limitations that must be resolved before a quantum numerical computational paradigm becomes a realistic possibility. Our results provide insight on what quantum arithmetic is currently feasible, and we have observed greater complexity in determining the optimal AQFT depth than initially anticipated. Many questions remain largely unanswered, and will require further study and simulation. One natural step forward is to continue the investigation of isolating the inter-dependency of different sources of error and order of superposition, as well as to what degree the AQFT mitigates them. Greater variation on how superposed state are entangled may also be informative. Simulations that isolate other sources of error, such as thermal relaxation, and qubit measurement errors, their simultaneous simulation with 1q-/2q- gate errors, as well as the impact of error mitigation and extrapolation from integers to real numbers, would offer a much more complete understanding of how these elements impact the QFT and AQFT. In addition, extending the study to larger $n$ would reveal whether the trends observed in this study continue or diverge, and may reveal other features that were suppressed at the smaller register sizes considered in this study. Further, the current study only considered methods for unsigned instances of QFA and QFM operations. Employing other methods, such as signed QFM, may reveal critical insight into current and new quantum algorithms, such as those for weighted-sum problems. Moreover, they will lay necessary foundation as future improvements in technology and techniques continue to make a quantum numerical computational paradigm more feasible.

§ ACKNOWLEDGMENT

We acknowledge fruitful discussion with Soham Pal and Weijie Du. We acknowledge the use of IBM Quantum services for this work. The views expressed are those of the authors, and do not reflect the official policy or views of IBM or the IBM Quantum team.

[1]
J J Álvarez-Sánchez, J V Álvarez-Bravo, and L M Nieto.
A quantum architecture for multiplying signed integers.
128:012013, aug 2008.

[2]
Hafiz Md Hasan Babu.
Cost-efficient design of a quantum multiplier–accumulator unit.
Quantum Information Processing, 16(1):1–38, 2017.

[3]
Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä.
Approximate quantum fourier transform and decoherence.
Physical Review A, 54(1):139–146, Jul 1996.

[4]
Amlan Chakrabarti and Susmita Sur-Kolay.
Designing quantum adder circuits and evaluating their error
In 2008 International Conference on Electronic Design, pages
1–6, 2008.

[5]
Andrew Cross.
The ibm q experience and qiskit open-source quantum computing
In APS March Meeting Abstracts, volume 2018, pages L58–003,

[6]
Thomas G Draper.
Addition on a quantum computer.
arXiv preprint quant-ph/0008033, 2000.

[7]
Maximilian Fillinger.
Data structures in classical and quantum computing, 2013.

[8]
Richard Jozsa.
Fidelity for mixed quantum states.
Journal of Modern Optics, 41:2315–2323, 1994.

[9]
Dawid Kopczyk.
Quantum machine learning for data scientists, 2018.

[10]
Frank Leymann and Johanna Barzen.
The bitter truth about gate-based quantum algorithms in the NISQ
Quantum Science and Technology, 5(4):044007, sep 2020.

[11]
Wiphoo Methachawalit and Prabhas Chongstitvatana.
Adder circuit on ibm universal quantum computers.
In 2020 17th International Conference on Electrical
Engineering/Electronics, Computer, Telecommunications and Information
Technology (ECTI-CON), pages 92–95, 2020.

[12]
Prakash Murali, Norbert Matthias Linke, Margaret Martonosi, Ali Javadi Abhari,
Nhung Hong Nguyen, and Cinthia Huerta Alderete.
Full-stack, real-system quantum computer studies: Architectural
comparisons and design insights.
In 2019 ACM/IEEE 46th Annual International Symposium on Computer
Architecture (ISCA), pages 527–540. IEEE, 2019.

[13]
John Preskill.
Quantum Computing in the NISQ era and beyond.
Quantum, 2:79, August 2018.

[14]
Lidia Ruiz-Perez and Juan Carlos Garcia-Escartin.
Quantum arithmetic with the quantum fourier transform.
Quantum Information Processing, 16(6):152, 2017.

[15]
V.V. Shende, S.S. Bullock, and I.L. Markov.
Synthesis of quantum-logic circuits.
IEEE Transactions on Computer-Aided Design of Integrated
Circuits and Systems, 25(6):1000–1010, Jun 2006.

[16]
Peter W. Shor.
Polynomial-time algorithms for prime factorization and discrete
logarithms on a quantum computer.
SIAM Journal on Computing, 26(5):1484–1509, Oct 1997.

[17]
Engin Şahin.
Quantum arithmetic operations based on quantum fourier transform on
signed integers.
International Journal of Quantum Information, 18(06):2050035,
Sep 2020.

[1]
J J Álvarez-Sánchez, J V Álvarez-Bravo, and L M Nieto.
A quantum architecture for multiplying signed integers.
128:012013, aug 2008.

[2]
Hafiz Md Hasan Babu.
Cost-efficient design of a quantum multiplier–accumulator unit.
Quantum Information Processing, 16(1):1–38, 2017.

[3]
Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä.
Approximate quantum fourier transform and decoherence.
Physical Review A, 54(1):139–146, Jul 1996.

[4]
Amlan Chakrabarti and Susmita Sur-Kolay.
Designing quantum adder circuits and evaluating their error
In 2008 International Conference on Electronic Design, pages
1–6, 2008.

[5]
Andrew Cross.
The ibm q experience and qiskit open-source quantum computing
In APS March Meeting Abstracts, volume 2018, pages L58–003,

[6]
Thomas G Draper.
Addition on a quantum computer.
arXiv preprint quant-ph/0008033, 2000.

[7]
Maximilian Fillinger.
Data structures in classical and quantum computing, 2013.

[8]
Richard Jozsa.
Fidelity for mixed quantum states.
Journal of Modern Optics, 41:2315–2323, 1994.

[9]
Dawid Kopczyk.
Quantum machine learning for data scientists, 2018.

[10]
Frank Leymann and Johanna Barzen.
The bitter truth about gate-based quantum algorithms in the NISQ
Quantum Science and Technology, 5(4):044007, sep 2020.

[11]
Wiphoo Methachawalit and Prabhas Chongstitvatana.
Adder circuit on ibm universal quantum computers.
In 2020 17th International Conference on Electrical
Engineering/Electronics, Computer, Telecommunications and Information
Technology (ECTI-CON), pages 92–95, 2020.

[12]
Prakash Murali, Norbert Matthias Linke, Margaret Martonosi, Ali Javadi Abhari,
Nhung Hong Nguyen, and Cinthia Huerta Alderete.
Full-stack, real-system quantum computer studies: Architectural
comparisons and design insights.
In 2019 ACM/IEEE 46th Annual International Symposium on Computer
Architecture (ISCA), pages 527–540. IEEE, 2019.

[13]
John Preskill.
Quantum Computing in the NISQ era and beyond.
Quantum, 2:79, August 2018.

[14]
Lidia Ruiz-Perez and Juan Carlos Garcia-Escartin.
Quantum arithmetic with the quantum fourier transform.
Quantum Information Processing, 16(6):152, 2017.

[15]
V.V. Shende, S.S. Bullock, and I.L. Markov.
Synthesis of quantum-logic circuits.
IEEE Transactions on Computer-Aided Design of Integrated
Circuits and Systems, 25(6):1000–1010, Jun 2006.

[16]
Peter W. Shor.
Polynomial-time algorithms for prime factorization and discrete
logarithms on a quantum computer.
SIAM Journal on Computing, 26(5):1484–1509, Oct 1997.

[17]
Engin Şahin.
Quantum arithmetic operations based on quantum fourier transform on
signed integers.
International Journal of Quantum Information, 18(06):2050035,
Sep 2020.

[1]
J J Álvarez-Sánchez, J V Álvarez-Bravo, and L M Nieto.
A quantum architecture for multiplying signed integers.
128:012013, aug 2008.

[2]
Hafiz Md Hasan Babu.
Cost-efficient design of a quantum multiplier–accumulator unit.
Quantum Information Processing, 16(1):1–38, 2017.

[3]
Adriano Barenco, Artur Ekert, Kalle-Antti Suominen, and Päivi Törmä.
Approximate quantum fourier transform and decoherence.
Physical Review A, 54(1):139–146, Jul 1996.

[4]
Amlan Chakrabarti and Susmita Sur-Kolay.
Designing quantum adder circuits and evaluating their error
In 2008 International Conference on Electronic Design, pages
1–6, 2008.

[5]
Andrew Cross.
The ibm q experience and qiskit open-source quantum computing
In APS March Meeting Abstracts, volume 2018, pages L58–003,

[6]
Thomas G Draper.
Addition on a quantum computer.
arXiv preprint quant-ph/0008033, 2000.

[7]
Maximilian Fillinger.
Data structures in classical and quantum computing, 2013.

[8]
Richard Jozsa.
Fidelity for mixed quantum states.
Journal of Modern Optics, 41:2315–2323, 1994.

[9]
Dawid Kopczyk.
Quantum machine learning for data scientists, 2018.

[10]
Frank Leymann and Johanna Barzen.
The bitter truth about gate-based quantum algorithms in the NISQ
Quantum Science and Technology, 5(4):044007, sep 2020.

[11]
Wiphoo Methachawalit and Prabhas Chongstitvatana.
Adder circuit on ibm universal quantum computers.
In 2020 17th International Conference on Electrical
Engineering/Electronics, Computer, Telecommunications and Information
Technology (ECTI-CON), pages 92–95, 2020.

[12]
Prakash Murali, Norbert Matthias Linke, Margaret Martonosi, Ali Javadi Abhari,
Nhung Hong Nguyen, and Cinthia Huerta Alderete.
Full-stack, real-system quantum computer studies: Architectural
comparisons and design insights.
In 2019 ACM/IEEE 46th Annual International Symposium on Computer
Architecture (ISCA), pages 527–540. IEEE, 2019.

[13]
John Preskill.
Quantum Computing in the NISQ era and beyond.
Quantum, 2:79, August 2018.

[14]
Lidia Ruiz-Perez and Juan Carlos Garcia-Escartin.
Quantum arithmetic with the quantum fourier transform.
Quantum Information Processing, 16(6):152, 2017.

[15]
V.V. Shende, S.S. Bullock, and I.L. Markov.
Synthesis of quantum-logic circuits.
IEEE Transactions on Computer-Aided Design of Integrated
Circuits and Systems, 25(6):1000–1010, Jun 2006.

[16]
Peter W. Shor.
Polynomial-time algorithms for prime factorization and discrete
logarithms on a quantum computer.
SIAM Journal on Computing, 26(5):1484–1509, Oct 1997.

[17]
Engin Şahin.
Quantum arithmetic operations based on quantum fourier transform on
signed integers.
International Journal of Quantum Information, 18(06):2050035,
Sep 2020.

Success rates (vertical axes) of quantum addition of two 8-qubit qintegers performed in the Quantum Fourier Basis with varying gate error rates, number of superposed addend state, and AQFT approximation depth; see Sec. <ref> for details. The left/right column presents results with varying 1q-gate/2q-gate error rate, ($P_{1q}^{err\%}/P_{2q}^{err\%}$) on the horizontal axes, respectively. The top/middle/bottom row shows results for (1:1)/(1:2)/(2:2) superposed addend states. Color-coded results for each depth of AQFM approximation depth are clustered along the horizontal axes and are only shifted apart horizontally for visibility; the alignment of the center-most point of a cluster reflects the gate error rate used for all calculations in that cluster. The `full' approximation depth designates that the full QFT circuit is performed in those simulations.

Success rates (vertical axes) of quantum multiplication of two 4-qubit qintegers performed in the Quantum Fourier Basis with varying gate error rates, number of superposed multiplicand state, and AQFT approximation depth; see Sec. <ref> for full details. The left/right column presents results with varying 1q-gate/2q-gate error rate ($P_{1q}^{err\%}/P_{2q}^{err\%}$) on the horizontal axes, respectively. The top/middle/bottom row shows results for (1:1)/(1:2)/(2:2) superposed multiplicand states. Color-coded results for each depth of AQFM approximation depth are clustered along the horizontal axes and are only shifted apart horizontally for visibility; the alignment of the center-most point of a cluster reflects the gate error rate used for all calculations in that cluster. The `full' approximation depth designates that the full QFT circuit is performed in those simulations.