Apr 24
quantum information & computing
discuss quantum basic notions
- formalism is "Hilbert space",
- i.e. complex linear algebra with unitary operators
- "ket" vectors and superposition
- EPR, spin, and entangled states
Now: apply all that to logic gates
classical
- bit
- can copy (measure) at will
- error correction depends on it, eh?
- logic gates: NOT, AND, OR
- XOR is reversible
- ... but AND, OR are not.
qubit
- both 1 & 0 (!?)
- but can't copy (that would 'measure' it)
- can entangle ; can't clone
- but can send it (via 'quantum teleporation')
- and can fixi errors (via 'quantum error correction')
qubyte
- entangled quantum states
- decoherece issues galore
- reversible 'quantum gates' instead of NOT, AND, OR
connections between information and energy :
- boltzmann's entropy | shannon's entropy
- in logic gate :
- information lost (e.g. non-reversible, i.e. AND, OR)
- => energy lost (e.g. "it gets hot")
- unitary (i.e. XOR)
- => no energy lost; states just rearranged (!)
traditional QM state evolution comes in two sorts :
- wavefunction evolution, which is unitary
- wavefunction collapse, which is non-reversible
wikipedia articles:
- qubit
- qubyte
- quantum information
- quantum teleportation **
- quantum gate **
- quantum circuit
- toffoli gate
- fredkin gate
- quantum algorithm
- shor's algorithm (factoring big numbers)
- quantum fourier transform
- quantum turing machine
- quantum error correction **
www.qubit.org/tutorials.html
- explanation levels :
- newspaper
- SciAm
- undergrad QM
- research
particularly
Chad's sources
1. general
2. algorithms
from Williams' "Explorations in Quantum Computing", pg 35+
computation model:
- classical: LOAD-RUN-READ
- quantum: PREPARE-EVOLOVE-MEASURE
contrived sample problem:
f = "constant" iff f(0)=f(1) ; "balanced" iff f(0)!=f(1)
on n bits, either constant or 0 50% of time, 1 50% of time.
to measure which, 2**n / 2 operations
The quantum version looks like this :
|x> = input, |y> = output
... but QM is unitary, so instead we set it up to evolve to
|x>|y> ---> |x>|y + f(x)>
where + is XOR
note that if y=0, we get what we want
|x>|0> ---> |x>|f(x)>
but with y=0 and y=1, we have a unitary (reversible) transform
(in what follows I'm leaving out the 1/sqrt(2) normalization factors)
Now consider what happens if y is a superposition {|0> - |1>}.
Output is |x>{ |0+f(x)> - |1+f(x)> }.
But by looking at all (x,f(x)) possible outcomes,
it's straitforward to show that this is the same as
(-1)**f(x) |x>{|0> - |1>}
since if f(x) is 0 it has no effect, but if its 1 it flips y by 180.
In other words, f(x) can be thought of as a phase term.
Next set |x> = {|0> + |1>}.
(which can be done with a "Walsh-Hadamard gate applied to |0>).
Doing out the math gives as the final state
{((-1)**f(0) + (-1)**f(1))|0> +
((-1)**f(0) - (-1)**f(1))|1>} {|0> - |1>}
And so measuring the 1st bit tells us whether f(0), f(1)
are the same or different.
It turns out that even with n bits, the quantum computer
can do this calculation in just ONE step. A similar construction
measured with <000000...|<y| (n bits; 1 extra for output)
gives an amplitude = sum{(-1)**(f(x_i))} ; which for a balanced
function is 0. Any other output means its constant.
Essentially the different answers interfere with each other,
and can give us one overall answer in the form we want
... if we're clever enough.
