arXiv:1701.

05550v1 [quant-ph] 19 Jan 2017

Is there a quantum limit on speed of

computation?
Nikolai A. Sinitsyn1
1

Theoretical Division, Los Alamos National Laboratory, Los

Alamos, NM 87545, USA
January 20, 2017

It has been widely argued that time-energy uncertainty relation in quantum

mechanics imposes limits on computation speed at given power of computer operation [1, 2]. Such claims are generally justified by the fact that digital computers save information in the form of clearly distinguishable states, such as 0
and 1 that encode one bit of information. Quantum mechanically, distinguishable
states must be represented by orthogonal vectors that produce definitely different measurement outcomes. However, time of switching between two orthogonal
quantum states is restricted by a fundamental limit T = h/(4E), where E is
characteristic energy of coupling to the control field that is needed to update one
memory bit [3]. While the existence of this limit is a mathematically proved fact,
I will argue that it is not sufficient to conclude that there is a limit on speed of
computation with a machine that uses quantum memory.
The phase space of a qubit is a continuum so, if orthogonality requirement is
removed, one can encode information in state vectors that are arbitrarily close to
each other. In fixed time, switching between such states can be done then with
an arbitrarily weak control signal. Certainly, such states are not precisely distinguishable so there is doubt about usefulness of computation schemes that save
information in non-orthogonal states. In this note I provide an explicit example
that demonstrates possibility of solving a computational problem while avoiding
switches between orthogonal states. Hence, at least some computational problems
may require arbitrarily small amount of energy per elementary computation step.
1

Imagine that our machine receives a long string of characters, say zero and
unit numbers:
1, 1, 0, 0, 1, 0, 1, . . . , 0, 1, 1.
The number N of unit characters in the string is unknown, and computer has
the task to answer the question: which one of the numbers, 0 and 2, is not the
remainder of division of N by 4? For example, let N = 1729 = 432 4 + 1.
Since the remainder is 1 then neither 0 nor 2 is the remainder. Hence, if machine
returns either 0 or 2 it gives a correct answer in this case. Another example:
N = 8 = 2 4 + 0. The remainder is 0 so the only correct answer that machine
must return should be 2. However impractical the above question may sound, it
poses a legitimate computational problem.
Let us now estimate minimal hardware and energy resources that are needed
to solve this problem classically. Suppose that characters of the string arrive with
constant time intervals , which set the speed of an elementary computation step,
while units are separated by unknown chains of zeros. Each time a unit number
arrives, we must update our records. Since only remainder of division by 4 matters, we need just two classical memory bits. We let the first bit flip each time a
new unit arrives, so its states 1 and 0 encode the parity (even/odd, respectively)
of the number of received units. Second bit starts in state 1 and flips when a unit
character arrives but only when the first bit is in state 0 prior to this event. States 0
and 1 of the second bit correspond then to the needed information about whether,
respectively, 0 or 2 are not remainders of division of N by 4. At the end of computation, measurement should be performed on the second bit. Since classically
distinguishable states must be quantum mechanically orthogonal, each flip of a
memory bit should be induced by a pulse with coupling energy E h/(4 ).
This is the minimal energy cost of counting each unit character classically.
Quantum mechanically, the same computational problem can be solved with
only a single qubit. Indeed, let us assume that a qubit is represented by a spin1/2, which points down along z-axis initially. Each time a unit character arrives, it
triggers a magnetic field pulse, along the y-axis, that rotates the spin counterclockwise by an angle /2 in the xOz plane. Remainders {0, 1, 2, 3} are then encoded
in spin rotation angles, respectively, {0, /2, , 3/2}. Note that we identify rotation angles that are different by multiples of 2 because they represent the same
spin state vector.
After the full string of characters passes through such a computation, we perform measurement by a projection operator on the state with zero rotation angle:
= |0ih0|.
X
2

(1)

Although the spin states that encode possible remainders are generally not orthogonal, particular states that represent remainders of interest, 0 and 2, are represented
by quantum mechanically orthogonal states with spin rotation angles, respectively,
0 and . Suppose the outcome of measurement is X = 1. This outcome is possible only for spin rotation angles 0, /2, 3/2 but not . So, receiving X = 1
we will conclude that the number 2 is definitely not the remainder of division of
N by 4. In the alternative case when the measurement outcome is X = 0, we will
conclude that 0 is definitely not the remainder of division of N by 4. So, our task
will be achieved.
Let us now examine energetics of this computation. At each elementary step
spin rotates by angle /2, which is half of what is needed to switch to the orthogonal state. Repeating standard arguments, e.g. from Ref. [3], I conclude that such
an elementary operation requires coupling energy that is limited by E = h/(8 ),
i.e., half of what is needed for switching to the orthogonal state. For spin-1/2, this
limit is reachable because it is achieved by a square pulse of a constant magnetic
field along the y-axis. Consequently, by using quantum memory we reduce energy
needs of our processor by half or, equivalently, speedup calculations by a factor 2
at fixed strength of the control field.
Our example can be easily extended to demonstrate that there are tasks that
may require arbitrarily weak control fields for elementary computation. Let us
consider the remainder of division of an unknown number N of arriving units by
an arbitrary even number 2n, where n is a positive integer. We ask the question:
which one of the numbers 0 and (n1) is not the remainder of such a division? We
can encode each remainder k {0, . . . , 2n 1} in spin-1/2 rotation angles k =
2k/(2n). Then in the limit n , at N > 2n, each elementary computation
(i.e. counting of an arriving unit) corresponds to spin rotation by an angle =
/n 0, so the energy cost per one elementary computation on the way to solve
this problem vanishes.
Interestingly, achieving superior performance of our quantum machine has not
involved entanglement of multiple qubits, which is needed for standard quantum
algorithms. Therefore, energy efficiency is a different and possibly experimentally
more accessible advantage of using quantum memory for computation. Physical
implementation of our quantum processor can be a quantum dot with a spin bound
state that counts the number of electrons passing nearby, as discussed in [4].
Acknowledgements. The work was carried out under the auspices of the National Nuclear Security Administration of the U.S. Department of Energy at Los
Alamos National Laboratory under Contract No. DE-AC52-06NA25396. I also
thank the support from the LDRD program at LANL.
3

References
[1] N. Margolus, L. B. Levitin, The maximum speed of dynamical evolution,
Physica D. 120: 188-195 (1998).
[2] S. Lloyd,Ultimate physical limits to computation, Nature 406, 1047-1054
(2000).
[3] L. Vaidman, Minimum time for the evolution to an orthogonal quantum
state, Am. J. Phys. 60 (2), 182-183 (1992).
[4] L. S. Levitov, H. Lee, and G. B. Lesovik, Electron Counting Statistics and
Coherent States of Electric Current, J. Math. Phys., 37 (10), 4845-4866
(1996).