Symmetry boosts quantum computer performance

0.45 MB·

by  Y. S. Nam

Symmetry boosts quantum computer performance
Y. S. Nam and R. Blu¨mel
Department of Physics, Wesleyan University,
Middletown, Connecticut 06459-0155, USA
(Dated: January 28, 2016)
6
1 Abstract
0
2 Frequently, subroutines in quantum computers have the structure FUF−1, where F is some

n
a unitary transform and U is performing a quantum computation. In this paper we suggest that if,
J
7 in analogy to spin echoes, F and F−1 can be implemented symmetrically such that F and F−1
2
have the same hardware errors on the logical qubit level, a symmetry boost in the fidelity of the
]
h
p combined FUF−1 quantum operation results that in our simulations reaches up to a factor 10.
-
t While we find and document this symmetry boost here in the case of Shor’s algorithm, we suggest
n
a
u that other quantum algorithms might profit from similar symmetry performance boosts whenever
q
[ FUF−1 sub-units of the corresponding quantum algorithm can be identified.

1
v
7 PACS numbers: 03.67.Lx
9
4
7
0
.
1
0
6
1
:
v
i
X
r
a
1
The second half of the 20th century saw the advent of the information technology revo-
lution. There is no doubt about its profound impact on just about every aspect of modern
society. The technological innovation in computers and networks enabled us to achieve
tasks previously thought to be impossible, such as weather forecast, telecommunication, the
Global Positioning System, and online banking.
While the current classical technology is already impressive, yet another revolution is
about to emerge: Quantum information technology [1]. Taking advantage of quantum su-
perposition and entanglement, a quantum information device is expected to be faster and
more secure than its classical counterpart. Epitomizing this is Shor’s algorithm [1, 2], which
enables us to factor a semiprime N = pq, where p and q are prime numbers, exponentially
faster than any classical algorithm known to date. Shor’s algorithm is often associated with
code-breaking since semiprime factorization is at the heart of the widely-employed Rivest-
Shamir-Adleman (RSA) encryption algorithm [1, 3].
Despiteallthetheoreticallypredictedstupendouspowersofquantuminformationdevices,
we do encounter major challenges when it comes to a physical realization of these devices:
Errors and defects. This is so, because a quantum system is known to be susceptible to
inexact manipulation and decoherence, especially for a quantum computer whose workings
are based on exquisite control of quantum superposition and interference. An early list of
the potentially dangerous physical mechanisms that may destroy the proper functioning of a
quantum computer was compiled by Landauer [4], and much progress has been made to fight
these detrimental mechanisms over the past couple of decades. For instance, overcoming the
stochastic type of errors, i.e., errors that occur on a single qubit probabilistically, was the
invention of quantum error correction [5–8] and its fault-tolerant implementation [9–11],
culminating in the standard de facto approaches of topological and surface codes (see [12]
and references therein).
Still, if we are to truly realize a working, physical quantum computer that is practically
useful, the limits of engineering must be taken into consideration. Otherwise, a quantum
computer will remain an academically interesting device of no practical relevance. One way
to approach this problem is to investigate the accuracy gain in logical operations on a logical
qubit, given the technology-dependent physical qubit error rate. Pioneering work in [13], for
instance, is already making headway in this direction. Yet, another way to help realize the
full potential of quantum computing is to investigate the algorithmic performance behavior
2
at the logical qubit level, providing quantum experimentalists and engineers with a logical
error-rate target, potentially easing the accuracy and precision requirements. Adding to
recent experimental breakthroughs, such as reported in [14] and [15], this paper provides an
additional strategy for realizing a working, physical quantum computer.
AsatestbedalgorithmwechoseShor’salgorithm, implementedaccordingtoBeauregard’s
architecture [16]. We selected this particular architecture based on the facts that (i) Shor’s
algorithm is arguably the most interesting and most important quantum algorithm to date,
(ii) the algorithm is complex enough to realistically capture the effects of faulty gates, and,
most importantly, and exploited in this paper, (iii) Beauregard’s architecture allows us to
take advantage of symmetry. Whether some other Shor algorithm architectures, such as
those presented in [17] (and references therein), may be exploited in a similar fashion is
currently under investigation and the results will be reported elsewhere.
Studies addressing the effects of errors and defects on a quantum computer running
Shor’s algorithm continue to be of central interest to many scientists. A list of early, notable
contributions includes the investigations by Cirac and Zoller [18] studying the effect of errors
in interaction time and laser detuning, Miquel et al. studying the effects of interactions with
a dissipative environment [19] and phase drift errors [20], Wei et al. exploring the effects
of coherence errors occurring while the quantum computer is idling [21], and Garc´ıa-Mata
et al. simulating static imperfections in Shor’s algorithm [22]. Recent developments in
quantum simulation software [23, 24] reflect the fact that quantum computers remain at the
forefront of research. Our work extends this line of research in that we simulate the entire
Shor algorithm gate–by–gate. In particular, we investigate the effects of phase-rotation gate
errors.
Since the most frequently used quantum gate in Beauregard’s architecture of Shor’s al-
gorithm is a phase rotation gate
1 0
(±)  
θ = , (1)
j 0 e±i2πj
which appears ∼ 18L4 times throughout the algorithm [27] when using the minimally re-
quired number of qubits to factor a semiprime N whose bit-length is L, we tested the
sensitivity of the quantum computer running Shor’s algorithm with respect to effective er-
(±)
rors introduced in θ . Specifically, we used a statistical error model of the rotation gate
j
3
[26] of the form
1 0
Rθ(±) =  , (2)
j 0 e±i2πj(1+α(±))
in the case where the errors scale according to the size of the gate operation and
1 0
Aθ(±) =  , (3)
j 0 e±i(2πj+α(±))
in the case where the errors do not scale according to the size of the operation. In both
cases α(±) is the defect parameter that may or may not be (strongly) correlated with the
gate type indexed with j. In case a one-to-one correlation exists, we call the error “typed”
and replace α(±) with α(±). The ± sign corresponds to forward and backward operation.
j
The reason why we investigate these two error models is as follows. First, any device has
a finite accuracy, and this is usually given in terms of percentage error with respect to the
size of the gate operation. Since a rotation gate θ is built according to a gate decomposition
j
sequence (see references in [25]), together with the faulty logical gates, the approximated
rotation gate will contain errors that scale in the size of the operation, especially regarding
the construction method of θ by applying θ twice, for instance. This iteration method
j j+1
may be realistic and desirable from the technological or economical perspective. Thus,
characterizing a device in terms of relative errors is captured by the Rθ(±) model. However,
j
suppose we characterize our quantum computer device in terms of its technological limit,
say δ. In this case, most likely, all gates are to be made with different sequences resulting
in an error level . δ, and this is captured by our model Aθ(±).
j
± ±
We now subdivide both models into 3 categories: (i) typed errors (α = α ), asymmetric
j
(α+ 6= α−), (ii) typed errors (α± = α±), symmetric (α+ = α−), and (iii) non-typed errors,
j
±
i.e., completely random α . The three categories are explained as follows. Typing arises
from using the same sequence, or the same physical device, for the same θ that occur
j
multiple times throughout the entire Shor algorithm. Then, depending on the way that
the physical device is set up, since the backward gate is nothing but a unitary inverse of
the forward gate, we may assume that the errors of the forward and backward gates are
symmetric. Therefore, while (i) and (ii) capture systematic errors, (iii) deals with random
errors.
To start with, we simulate the case of factoring N = 15. This is the case used in
[20], which allows us to compare the results. Defining fidelity F = |hΨ |Ψ i|2 as in
actual ideal
4
a
1
F 0.8
0.6

0.4
0.2
0
0.001 0.01 σ 0.1 1

b
1
F 0.8
0.6

0.4
0.2
0
0.001 0.01 σ 0.1 1

c
1
F 0.8
0.6

0.4
0.2
0
0.001 0.01 σ 0.1 1

FIG. 1: Fidelity F of a quantum computer factoring N = 15 with seed 2 as a function of standard
deviationσ ofthelogical-gate errors. Intheorderofa,b,andc, thequantumcomputerisequipped
withaddersthatarecapableofbeingusedinShor-algorithm-factoringof4,5,and6-bitsemiprimes.
Shown are the cases of typed, asymmetric errors (triangles), typed, symmetric errors (squares),
and non-typed, random errors (circles). Filled plot symbols (Red, Blue, and Black) denote relative
errors [see Eq.(2)] and the open plotsymbols (Orange, Cyan, and Grey) denote absolute errors [see
Eq.(3)]. Dashed lines connecting plot symbols are drawn to guide the eye. The solid, horizontal
lines correspond to F = 0.
5
[20], in Fig. 1 we plot F as a function of σ, where the errors α(±) are Gaussian distributed
random variables with mean 0 and standard deviation σ. At first glance, we observe that the
quantum computer performs better in the order of the asymmetric, random, and symmetric
errors. In particular, symmetric errors give rise to a fidelity boost in σ by an astonishing
factor of ∼ 10 in both the Rθ± and the Aθ± models.
j j
To better feature the symmetry-driven fidelity boost, this time we plot, in Fig. 2a, the
fidelity F of Shor’s algorithm as a function of the number of qubits n, while fixing the error
strength σ = 10−8/3, 10−6/3, and 10−4/3 for asymmetric, random, and symmetric errors,
respectively. The error strengths were chosen so that the corresponding resulting fidelities
are roughly of the same magnitude, pointing to the fact that there exists a fidelity boost due
to symmetry. A surprising result: Not only does the fidelity boost persist, but the boost is
in fact enhanced as a function of increasing n. While one may expect that the fidelity should
decrease for increasing n (after all, the quantum computer is exposed to a larger number of
erroneous gates), for the symmetric case, apparently, there is an anomalous initial increase
in F.
In an attempt to find the scaling relation of F for Shor’s algorithm as a function of σ
and n, we now probe a smaller computational unit of Shor’s algorithm. In Figs. 2b and c,
we plot the fidelity F of a U-gate as a function of the bit-length L of the adder, equipped
with uncorrelated relative and absolute errors, respectively (as shown in [16], a U-gate is a
multipliergate, i.e., acomputationalunitonelevelsmallerthanafullmodulo-exponentiation
gate). Numerically we find that the U-gate fidelities for both cases are Gaussian in both
σ and L (see caption of Fig. 2 for details). The results are in excellent agreement with
the corresponding data in Fig. 1 and Fig. 2a, obtained by multiplying a factor 2L to the
exponent of the U-gate scaling relations (not shown), reflecting the fact that there are 2L
U-gates in a complete modulo-exponentiation circuit in Shor’s algorithm. For reference we
note that, according to [16], n = 4L+3.
While similar behavior is observed for the interesting symmetric cases at the U-gate level,
currently no explicit formula is available. At present, it is sufficient to note that, for a given
L, the U-gate fidelity is (i) Gaussian in σ for small σ and (ii) exponential in σ for large σ.
Explicit numerical computations show that the scaling parameters are sensitive to both the
multiplier of a U-gate and the semiprime N. An additional difficulty arises in predicting
the fidelity scaling of the entire Shor algorithm: The technique of multiplying a factor 2L
6
a b
1 1
0.9
F
F 0.8
0.7 γ
0.6 700
0.5 500
300
0.4 L
0.1 4 5 6 7 8 9
0.3
18 20 22 24 26 n 28 30 32 4 5 6 7 L 8 9

c d
1
γ
F
100
γ
700
500

300
100
L
0.1 4 5 6 7 8 9
10
4 5 6 7 L 8 9 4 5 6 7 8 9L 10 11 12 13

FIG. 2: Fidelity F of Shor’s algorithm running in various modes. Frame a: Factoring 15 with
seed 2 with n = 19,23,27 and 31 qubits, where σ = 10−8/3,10−6/3, and10−4/3 for asymmet-
ric (triangles), random (squares), and symmetric (circles) errors, respectively. Frames b and c:
Fidelity F of a U-gate (see [16]) computing the controlled modulo-multiplication 2 × 1 mod 15
with the control qubit turned on (qubit state |1i), as a function of adder size L, defined as the
maximal bit-length of a semiprime that may be factored when the adder is used in Shor’s al-
gorithm. The U-gates are equipped with adders that contain random errors (b: relative and c:
absolute). Shown are the cases with σ = 0.01 (pluses/red), σ = 0.02 (squares/green), σ = 0.03
(crosses/blue), σ = 0.04 (circles/purple), and σ = 0.05 (asterisks/cyan). Black lines are fit-lines of
the form exp −10(L+5)2σ2/3 and exp −10(L−1.2)2σ2 for Frames b and c, respectively. In-
(cid:2) (cid:3) (cid:2) (cid:3)
sets in Frames b and c show γ, defined according to F = exp[−γ(L)σ2], for σ = 0.01 as a function
of L. Frame d: An equivalent plot to the insets in Frames b and c for symmetric errors. Pluses
(red) and crosses (green) are absolute and relative errors, respectively. Dashed lines guide the eye.
The fit functions (orange solid lines) for the tail regions are exp[(L+9)/4] and exp[(L+24)/10]
for absolute and relative errors, respectively.
7
to the exponent of the U-gate fidelity scaling fails. A pleasant surprise, on the other hand,
is the following: The true Shor fidelity outperforms expectations.
Remaining in the small-σ regime [case (i)], important for practical applications, and as-
suming the functional formexp(−γσ2) of the fidelity of the U-gate equipped with correlated,
symmetric noise, we extract the coefficient γ and plot it against L in Fig. 2d. Consistent
with earlier observations, the U-gate initially performs better as a function of increasing
L, reverting to the expected behavior of deteriorating fidelity for L > L . While the exact
c
scaling relation of L is currently unknown and forms a topic for future investigations, in the
c
remaining part of the paper, we turn to a more important question: Is the symmetry-driven
fidelity boost persistent in n (and/or L)?
Trackingdowntheoriginoftheanomalousbehavior, wefirsttestedvariouscomputational
sub-units of Shor’s algorithm. We find that a modulo-addition gate is the smallest unit that
exhibits the symmetry-driven fidelity boost. In Fig. 3a and b, we plot the fidelity F of the
modulo-addition gate, equipped with the typed, symmetric, relative and absolute errors,
respectively, executing 0+2 mod 15 as a function of the bit-length L of the adder for various
error levels σ. We observe that both types of errors result in an initial boost in fidelity,
followed by deterioration. We note that while the relative kind of errors shows sustained
deterioration of F in L, as would be expected from further introducing relatively more noisy
gates, the absolute kind of errors nearly plateaus out. This may be explained as follows.
While the absolute kind of noise may drown out the rotation gates with rotation angles
smaller than the noise amplitude, it leaves those with angles larger than the noise amplitude
relatively unaltered, effectively keeping the hierarchy of rotation angles (i.e. θ < θ )
j+1 j
intact. This observation agrees with the findings in [28], i.e., banding and hierarchy in
certain quantum circuits, such as in the quantum Fourier transform (a backbone subroutine
of Shor’s algorithm [16]), are the determining factors of the performance of a quantum
computer.
We now turn to the question of persistence of the symmetry-induced performance boost
for different semiprimes. So far, we have used N = 15 as our test case. The question now
is whether for all other N’s the performance boost continues to be observed. In particular,
we are interested in how the fidelity changes when additional qubits are introduced into
the modulo-addition gate. To this end, we numerically simulated 0+2 mod N for all odd
semiprimes N < 213 with 0, 1, 2, and 3 additional qubits in the modulo-addition gate and
8
a b
1 1
F F

0.2 0.2
5 10 L 20 5 10 L 20

c d
1 1
0.9 0.9
F F
0.8 0.8

0.7 0.7
0.6 0.6
0.5 0.5
0 2000 4000 6000 8000 0 2000 4000 6000 8000
N N

e f
0.9 0.9
F F
0.8 0.8
0.7 0.7
32 128 512 2048 8192 32 128 512 2048 8192
N N

FIG. 3: Fidelity F of a modulo-addition gate performing 0+2mod N, where N is a semiprime.
Frames a and b show F as a function of the bit-length L of the maximal semiprime that may be
factored using the employed modulo-addition gate, equipped with relative and absolute symmetric
errors, respectively. All cases were performed with N = 15. In decreasing order of F, different plot
symbols refer to σ = 0.1,0.2,...,0.9. The solid black lines in Frame a are the large-L regime fit-
lines(2σ+0.3)−2/3 forσ ≥ 0.6. Frames canddshowF asafunctionofalloddsemiprimesN < 213
for relative and absolute symmetric errors, respectively. The error strength used is σ = 0.2. In
the order of pluses (red), crosses (green), asterisks (blue), and squares (purple), the adders are
equipped with 0, 1, 2, and 3 additional qubits than minimally required. Frames e and f show
logarithmically averaged F, i.e., each plot point at x-coordinate of 2j+1/2 is the result of averaging
over N from 2j to 2j+1, where 3 ≤ j ≤ 12. Notice that for j = 3 and j = 4, there is only one
semiprime each, namely, 15 and 21, respectively, resulting in larger fluctuations due to insufficient
statistics. Solid lines in Frame e, with corresponding color symbols, are the tail-region fit lines
F = 0.807,0.9,0.89, and0.87. Solid lines in Frame f, with corresponding color symbols, are the
tail-region fit lines (to first order) F = −0.01log (N)+k, where k = 0.827,0.918,0.885, and 0.841
2
for the four cases shown.
9
plot the resulting F as a function of N in Fig. 3 c and d for the relative and absolute
cases with σ = 0.2, respectively. Clearly, we see that for all semiprimes we tested, there
is an apparent fidelity boost for both relative and absolute errors. Another interesting
phenomenon is that semiprimes N between 2j and 2j+1 are sectioned into different F-bands,
probably arising from the bit-spectra of different N values, i.e., the binary digit 1 in the digit
spectrum of N turns on the corresponding noisy rotation gate operation. This, however,
forms a subject of research in itself and is beyond the scope of this paper.
Tohighlight theresult shown inFig.3candd, we averagedF over N inlogarithmicscale,
i.e., 2j < N < 2j+1 for j = 3,4,...,12, and plot the results in Fig. 3e andf, respectively. We
immediately confirm that the performance boost persists. In addition, we see that (A) the
fidelity does not scale in N for the relative type of noise and (B) the fidelity does scale in N,
like ∼ log (N), for the absolute type of noise. While the exact reasoning behind these two
2
observations is currently unknown, on the basis of the following two arguments we speculate
that (A) and (B) are direct consequences of the hierarchical structure competing with the
fixed-strength errors. First, additional qubits used in the modulo-addition gates correspond
to increasing the depth of the hierarchy of the quantum gates, which helps increase F in
the absence of errors. Then, for a fixed-strength error σ > 0, the relative kind affects the
entire hierarchy of the modulo-addition gates evenly, i.e., all constituent rotation gates of
the modulo-addition gates are subjected to the same relative strength of errors. This results
in the plateau behavior of F as shown in Fig. 3 e. In contrast, the absolute kind of errors
drowns out all rotation gates with rotation angles less than the noise level, which necessarily
comes about as N increases. This is consistent with the scaling of F in log (N) ∼ L (see
2
Fig. 3 f) in that the number of drowned-out gates scales in L as well.
While we conjecture that the symmetry boost presented in this paper persists in the
regime of a large number of qubits, we were able to check this explicitly only for n ≤ 31.
Going beyond, however, becomes prohibitively expensive, taking into account that a large
number of runs are needed to gather statistics. For instance, let us take a look at memory
requirements. With double-precision complex numbers, a single run of the n-qubit case
requires at least 2n−26 GB of RAM, which already for n = 300 (a relatively small number of
qubits in view of practical applications), amounts to more than 1080 GB, which exceeds the
classical resources of the entire known universe. Together with a runtime that is exponential
in n, any classical computer, present or future, quickly reaches its limits. Nonetheless, on
10