I have no background in quantum physics, and no understanding of most formulas used in this context. I'm not looking for an in depth answer, i'd just like to vaguely understand the concept.

The way i heard it, a superposition is [real/a neccessary assumption/a concept not even wrong/whatever] and will end as soon as the object in superposition is observed. I always took that "observed" part to mean "interacted with in a way that allows to make a decision on the state" and i further supposed there was no cheating a la "oh but i entangled A and B and now i just observed A, so B will be alright" and suchlike .

So now we have quantum computation, which seems to rely on the superpositions of objects somehow covering a whole lot of bases at once and then [something something] which produces an answer - my question is about the i/o process: How can i input something so a superposition is achieved that encompasses the information i input, without automatically destroying the relevant superposition? How can i be sure my input was put in without looking? how can i look without destroying the very thing i wanted?


I'm going to go for an intuitive answer here, as requested. Let's s go in steps:

  • Your input is (often?) classical, so up to that point we're good.
  • Then you start doing quantum operations and achieve, for example, quantum superpositions between different states. Here you're right, you cannot look to check if you're doing OK, and that indeed is a problem, or rather the origin for different problems. For more on that you could give a try to the tags quantum entanglement (what you want, often), quantum decoherence (what happens in the way) and quantum error correction (ways to fix the situation without observing, or to observe just-enough but not-in-a-destructive-way).
  • The last point, quantum error correction, is indeed a trick that is allowed. Here the key is observing, not the values of the qubits, but rather the relation between these values. With enough redundance and smart schemes, one can deduce what went wrong and where, and fix it without observing the values that are involved in the calculation. (Hopefully the 3-qubit bit flip code can be understood without understanding quantum mechanics, since C-not operations have basic truth tables?) In this way we sacrifice part of the quantum information while preserving the part that we care about.
  • In the end we also get a classical output. We lose a lot, but that's just how reality works. You can always repeat the calculation to extract information gradually, aim for quantum state tomography.

Finally, since others said it better than I could, consider this quotations (emphases mine).

First, by Scott Aaronson, "PHYS771 Lecture 14: Skepticism of Quantum Computing":

Q: OK, so you have the Threshold Theorem, but then you have to do some error correction, right? Your computation becomes longer, right?

Scott: Yeah, but by a factor of polylog(n). This isn't challenging the Church-Turing Thesis, but yeah, that's true.

Q: I'm not sure if you'd have to perform another error correction as you proceed.

Scott: The entire content of the Threshold Theorem is that you're correcting errors faster than they're created. That's the whole point, and the whole non-trivial thing that the theorem shows. That's the problem it solves.

And secondly, the abstract from arXiv:quant-ph/9712048 "Fault-tolerant quantum computation" by John Preskill:

The discovery of quantum error correction has greatly improved the long-term prospects for quantum computing technology. Encoded quantum information can be protected from errors that arise due to uncontrolled interactions with the environment, or due to imperfect implementations of quantum logical operations. Recovery from errors can work effectively even if occasional mistakes occur during the recovery procedure. Furthermore, encoded quantum information can be processed without serious propagation of errors. In principle, an arbitrarily long quantum computation can be performed reliably, provided that the average probability of error per gate is less than a certain critical value, the accuracy threshold. It may be possible to incorporate intrinsic fault tolerance into the design of quantum computing hardware, perhaps by invoking topological Aharonov-Bohm interactions to process quantum information.

  • 1
    $\begingroup$ I get the relations-but-not-states reasoning on the error correction schemes, abstracted it's actually a pretty common tactic in sciences on a whole - is there an contrieved example you could give to show this in action on quantums? $\endgroup$
    – bukwyrm
    Apr 21 '18 at 21:45
  • $\begingroup$ I added link to a 3-qubit bit flip code. I believe this is understandable with no physics background. Other codes are notably more sophisticated / difficult to follow (for me at least!). $\endgroup$ Apr 21 '18 at 21:52
  • $\begingroup$ So the error-checking leaves room for error that is checked, leaving room for error.... looks like both error and work-done-to-avoid-error are one of those infinite series that one has to really get into to see whether it converges on anything, and if so on what. But my question is mostly answered. $\endgroup$
    – bukwyrm
    Apr 21 '18 at 22:27
  • $\begingroup$ I included a couple of quotes in the answer (with links to learn more), in case they help to clarify what I think is a key point $\endgroup$ Apr 22 '18 at 5:24

The whole point is that you do not want, nor need, to "look" how the computation is going.

You can ensure that the input is what it should be by a variety of means. The simplest case being that you may simply trust that your apparatus, which you previously characterized very well, will produce what you ask it to produce.

After that, you will know whether the input will evolve into a superposition of different states simply because you generally know what the evolution of the system looks like. Again, because you know what your computer is going to do: you built it for that purpose. You will know that (for example) a specific sequence of entangling gates will be performed on the input, so that the state will evolve into a given superposition of states in the computational basis.

The crucial point here is that you do not, and cannot, look at the state during the computation. In other words, you have to think of the whole quantum algorithm/circuit as a black box: you built it so you (more or less) trust what it does, but after that you can just put an input and look at the resulting output.

Looking at the output does indeed destroy the coherence of the state (that is, roughly speaking, its being in a superposition of different states), but this is not a problem because quantum algorithms are designed in such a way that the measurements performed on the output give the answer to the problem.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.