Quantum Computing – the four challenges ?>

Quantum Computing – the four challenges

For all the spilled ink and breathless prose about quantum computing (QC), there remain four major challenges to overcome before it takes the place of classical silicon computing.

• Coherence (the quantum state of data)
• Entanglement (quantum teleportation)
• Error Correction
• Languages and compilers

The PC on your desk, the smartphone in your pocket, and the biggest computers at the NSA manipulate bits that can be either on or off, one or zero, true or false. In 1981, Richard Feynman described a computer that used quantum bits (qubits) that could exist in any state between zero and one. With such an approach, the machine could solve problems that were previously impossible. In 1994, Peter Shor developed an algorithm for a quantum computer that could crack RSA security, the system used for most encryption today (Shor, 1997). All we had to do was build a computer with quantum bits.


A working qubit computer at scale remains a dream, though closer every year. The quantum effect required to make a qubit requires something very small, an electron or a photon. No one has demonstrated this effect on something as large as a whole atom or molecule. To work with a single electron or photon requires a very quiet space. In physicists’ terms, quiet means cold. Otherwise, noise (heat) from nearby activity upsets the coherence of the qubit. Think of the qubit as a tiny spinning top made of ice. If the ice melts, the system doesn’t work. There is no ice in a quantum computer, nor does the qubit spin in the sense a child would recognize, but it is a nice analogy to describe how fragile the system is. Calculations in a QC involve rotating this spinning top a quarter or a half turn in pitch, roll, or yaw. That take some sensitive circuitry and gentle nudges.

The measure of success is how long the qubit lives – decoherence time. In 2013, researchers set a record of 39 minutes decoherence time (Saeedi, et al., 2013). That’s in a lab, not in a working computer. Observations of a D-Wave machine in 2015 showed a decoherence time on the order of nanoseconds (Drakova & Doyen, 2015). It’s not long enough yet to complete a computation.

The challenge for any builder of a quantum computer is to build one cold enough to maintain coherence for the time it takes to complete a computation. It needs to process the rotation commands quickly and reliably.


Quantum computers cannot copy qubit memory from one cell to another. Copying vast tracts of memory is common in classical computing. It takes time and energy, but it is simple. Not so in QC. Quantum computers offer an exciting alternative. A programmer can cause qubits to entangle. What happens to one of an entangled pair happens in mirror image to its partner. Researchers have measured the effect at 10,000 times the speed of light; we may assume that it is instantaneous. And it doesn’t require any wires. This effect, like coherence, has been demonstrated in the lab, but not in an actual computer.

Getting one qubit to reflect another by entanglement is also known as quantum teleportation. Teleportation is at once an evocative term and one that leads to all sorts of pseudoscience articles on the Internet.

Error Correction

Qubits are subject to error. They can lose coherence. The logic gates may not rotate the qubits through the exact arc desired. Researchers have claimed a 99.9% fidelity for their gate (Ballance, Harty, Linke, Sepiol, & Lucas, 2016). That’s good, but not enough for modern calculations. Shor proposed to implement entanglement across nine qubits (the original and eight more) to provide error-correcting redundancy. That means building computers with nine times as many qubits as the theoretical program would require.

Building a computer chip that includes many qubits, each of which is surrounded by the circuitry that allows the program to influence the qubit in pitch, roll, and yaw is no small challenge.


At the beginning of digital computers, programming was accomplished by physical rearrangement of the parts and wires. It was a breakthrough when programs could be input by switches or punched tape or cards. The first language, the one that touches the electronics, is called machine language. It is all ones and zeros. The next level of abstraction is Assembly (or Assembler), a language typically described by three letter commands. Early computer users typically used a language such as FORTRAN or COBOL that was transformed using a compiler to Assembly. Assembly is reflected in machine code. In the decades since, computer languages have become more and more abstracted from the machine. ANSI SQL is the same language no matter what machine it runs on. The development of these languages progressed incrementally from low level to high level. This orderly progression is not happening in QC.

In the years since FORTRAN and LISP were introduced for the IBM 704, programmers have developed preferences for what a programming language does and how it does it. After Feynman described quantum computers, programmers started thinking about how to program them, long before there was a physical machine to program. In 1996, researchers claimed that an extension to Lambda calculus was sufficient to describe a quantum computer program (Maymin, 1996). QPL and QFC were described five years before the first prototype quantum computer. More recently, languages Quipper and QML were introduced as research projects. They offer a quantum computer simulator, but no means of compiling code for an actual machine.

IBM allows the public to experiment with its Q-series prototype. To do so, the user may define the circuits and execute them using a drag-and-drop graphical interphase called Composer or an assembler called OpenQASM. With D-Wave’s introduction of its quantum computer, it released QMASM (Quantum macro assembler). Neither D-Wave’s nor IBM’s offering can realistically be described as a high-level language. We are going to need that if we are to put production-size QC machines to work.


Ballance, C., Harty, T., Linke, N., Sepiol, M., & Lucas, D. (2016). High-Fidelity Quantum Logic Gates Using Trapped-Ion Hyperfine Qubits. PHYSICAL REVIEW LETTERS. doi:10.1103/PhysRevLett.117.060504

Drakova, D., & Doyen, G. (2015). Long-time coherent quantum behaviour of the D-Wave machine. doi: arXiv:1503.08955v1 [quant-ph]

Maymin, P. (1996). Extending the Lambda Calculus to Express Randomized and Quantumized Algorithms. doi: arXiv:quant-ph/9612052v2

Saeedi, K., Simmons, S., Salvail, J. Z., Dluhy, P., Riemann, H., Abrosimov, N. V., . . . Thewalt, M. L. (2013). Room-Temperature Quantum Bit Storage Exceeding 39 Minutes Using Ionized Donors in Silicon-28. Science. doi:10.1126/science.1239584

Shor, P. W. (1997). Polynomial-Time Algorithms for Prime Factorization and Discrete Logarithms on a Quantum Computer. Society for Industrial and Applied Mathematics Review. doi:10.1137/S0036144598347011

Leave a Reply