Justin Dressel, Ph.D.
Institute for Quantum Studies, Chapman University
OC ACM Chapter Meeting, May 16th, 2018
IBM, Superconducting quantum computer
Anything "Turing Complete" can simulate a Turing Machine, and thus all classical computation.
Even Microsoft Excel
or Minecraft
Bits are definite physical configurations (0 or 1)
New "coherent" features for quantum bits (qubits)
These coherent features wash out (or "decohere") on the macro-scale to produce the classical picture
Classical Bit
Quantum Bit
Shares same "z-axis"
Decoheres as projection to indefinite classical state on z-axis
Only 2 definite states: 0 or 1
z-axis connecting them is indefinite, or probabilistic
Surface of sphere are definite states
Inside sphere are indefinite states
Idea : Treat quantum logic as superset of reversible logic
NOT
CNOT (controlled-NOT)
Toffoli (controlled-controlled-NOT)
3 new features in quantum generalization
NOT
Hadamard
Negatives in the "probability amplitudes" for the superpositions allow for "destructive interference" since they can cancel positives
Suppose a periodic sequence can be encoded as the amplitudes of a superposition
The quantum Fourier transform (QFT) finds periodicity in polynomial operations
# steps per n bits:
Detects that each successive phase factor is:
Caveat: Answer stored as superposition. Must randomly sample outputs to measure.
To factorize an n-bit integer, reduce the problem to a period-finding problem, then apply the quantum Fourier transform to exponentially speed it up. Since the resulting superpositions are periodic by construction, the main caveat of the QFT is mitigated.
Measured output : sparse,
easy to sample
Useful for breaking encryption!
Public key encryption (RSA) relies on the factoring of integers to be difficult
We already have them! ... sort of
2 main competing implementations (others in development):
But these numbers do not tell the complete story
A trapped ion qubit is a superposition of the lowest two magnetic hyperfine energy levels of an ion (like Ytterbium or Calcium)
Such ions are trapped and cooled with lasers, then manipulated with more lasers
A superconducting (transmon) qubit is a superposition of the lowest two energy levels of a charge oscillation (an "artificial atom") across a nonlinear inductive tunnel barrier attached to a capacitive antenna
UC Berkeley : 8 qubit chip
Controlled with all electrical AC signals at microwave frequencies
Cooled to mK temperatures
Yale : Transmon SEM
Chris Monroe, UMD
53 Trapped Fluorescing Ions, UMD
Government Labs
(MIT Lincoln Labs,
Sandia National Labs,
Laboratory for the Physical Sciences,
NIST)
Levitating trapped
ions as qubits
Bristlecone Chip
72 qubits
IBM Q Prototype
50 qubits
Rigetti 19Q Processor
19 qubits
If one bit flips, can detect and correct via majority-voting
Same basic idea, but now applied to superpositions
Main problem: cannot "look" at the bits directly due to measurement collapse
Resolution: measure parities of bits instead
Qubit Error Correction
Problem: qubits can do more than just flip - more can go wrong
Resolution: redundantly encode several types of information at once (e.g., multiple axes of the sphere), and measure several types of parities to fully detect and correct errors
Remarkably, protecting two independent types of error is sufficient to protect against all errors
Simple bitflip protection is not quite enough.
A very clever way to implement full quantum error correction for a 2D lattice of nearest-neighbor-coupled qubits is the "surface code"
Idea : Create three interspersed lattices
Can encode redundant information across entire area of the lattice to reduce error rate for the resulting logical qubit
Phys. Rev. A 86, 032324 (2012)
Shor's Algorithm needs a logical error rate of around 1e-20 per step
If each step has an error rate ~1e-3
(typical in very good hardware), then about 1e4 physical qubits will be needed to encode each logical qubit!
Phys. Rev. A 86, 032324 (2012)
Minimum qubit number :
Factoring run-time :
Phys. Rev. A 86, 032324 (2012)
Side note : Can reduce run-time by adding more qubits
(Compare to 6.4 quadrillion years for a classical desktop computer running the number sieve)
Growth in qubit number is currently exponential
If growth continues exponentially (with both fidelity and technical substrate scaling favorably) then we can expect chips with one billion qubits in:
~10-15 years
We are now reaching the scale that is no longer possible to simulate using classical supercomputers.
The current challenge is to find "near-term" applications for the existing quantum devices.
We are here
Idea : Quantum systems more easily simulate other quantum systems
(Proposed by Feynman in 1985)
Quantum Chemistry is an obvious application
Recent algorithms need only ~1e2 physical qubits for approximate solutions,
or
~1e2 logical qubits for
exact solutions
Two quantum algorithms for computing the bond energy for an H2 molecule using 3 qubits, compared to the numerical calculation using a classical computer
Experimental data already viable
For larger molecules, classical computers will no longer be able to numerically calculate these energies
(16 qubits free, 20+ paid)
operation Teleport(msg : Qubit, there : Qubit) : () {
body {
using (register = Qubit[1]) {
let here = register[0];
H(here);
CNOT(here, there);
CNOT(msg, here);
H(msg);
// Measure out the entanglement.
if (M(msg) == One) { Z(there); }
if (M(here) == One) { X(there); }
}
}
}
from qiskit import ClassicalRegister, QuantumRegister
from qiskit import QuantumCircuit, execute
from qiskit.tools.visualization import plot_histogram
# set up registers and program
qr = QuantumRegister(16)
cr = ClassicalRegister(16)
qc = QuantumCircuit(qr, cr)
# rightmost eight (qu)bits have ')' = 00101001
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])
# second eight (qu)bits have superposition of
# '8' = 00111000
# ';' = 00111011
# these differ only on the rightmost two bits
qc.h(qr[9]) # create superposition on 9
qc.cx(qr[9],qr[8]) # spread it to 8 with a CNOT
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])
# measure
for j in range(16):
qc.measure(qr[j], cr[j])
from math import pi
def qft3(q0, q1, q2):
p = Program()
p.inst( H(q2),
CPHASE(pi/2.0, q1, q2),
H(q1),
CPHASE(pi/4.0, q0, q2),
CPHASE(pi/2.0, q0, q1),
H(q0),
SWAP(q0, q2) )
return p
from projectq import MainEngine
from projectq.backends import CircuitDrawer
from teleport import create_bell_pair
# create a main compiler engine
drawing_engine = CircuitDrawer()
eng = MainEngine(drawing_engine)
create_bell_pair(eng)
eng.flush()
print(drawing_engine.get_latex())
Quantum computing is already here (mostly).
It is only a matter of time before a quantum computer accomplishes a task that is currently impossible on any classical computer.
Thank you!