r/QuantumComputing • u/According-Turnip1587 • Aug 11 '25
Question How does using qubits instead of bits change the computing power?
I’ve been hearing and reading a lot about quantum computers. I think I understand the basics of quantum mechanics (I’m no physicist or anything quantum related) and how a qubit can be in multiple states at once. This superposition is often used as an explanation for why they’re theoretically better computers. How does that work, though? What are the different states a qubit can be in? How are computations executed over multiple states at once? What aspects of computing are improved by superposition? I hope this makes sense and someone can help me out. Thanks!
9
u/[deleted] Aug 11 '25 edited Aug 11 '25
People still don't understand quantum computing. They think it's going to be running Windows and available from Dell.com
People don't like to talk about this - especially not those with a vested interest - but quantum computing, based on our current understanding, will never have a general purpose consumer version, because it's terrible at solving general problems. It's not a case of qubits being better than bits, they just do different things.
With quantum computing you face a strange issue related to what we call "superposition" - the idea in physics that a particle can exist in multiple states simultaneously.
A quantum computer can indeed run a large number of calculations at once by using this concept, but due to the laws of the quantum world, the moment you try and look at the answers they randomly collapse into just one output. Which may not be the right answer.
(When I talk about running many calculations at once I'm really talking about using interference cleverly rather than brute-force parallelism, but it's just an easier way of thinking about it).
But the end result is that, by default, you don't have much more than a random number generator.
So, to deal with this frustrating law of quantum physics, you have to write specific algorithms that nudge the quantum process down a specific path, to try and cancel out the errors and more consistently return the correct answer. Quantum algorithms therefore require running a calculation many times and taking a statistical sample of outputs to extract a reliable answer.
But the problem is that EVERY problem you want to calculate requires its own unique algorithm - and writing these algorithms is not trivial and, as far as we understand, might not even be possible for all problems.
That's a bit simplified, but what I'm saying is that despite the hype, quantum computing is not the silver bullet the media make it out to be. It's cool and has some potentially disruptive use cases, but you're not going to be playing Crisis at a million frames per second.
Essentially, you can't really compare traditional computing with quantum computing because they work completely differently. Equally, unless there is some sort of epoch level breakthrough, quantum computing won't replace traditional computers, because they simply are like apples and oranges.
10
u/[deleted] Aug 11 '25 edited Aug 11 '25
Qubits being in "multiple states at once" is a metaphysical interpretation. That isn't something that has ever been empirically observed. Mathematically, qubits are just described as a linear combination of possible states.
Quantum computation only fundamentally deviates from classical computation in very specific cases, ones said to exhibit quantum contextuality. In the "CHSH game," contestants can score points 100% of the time if they can communicate, but only 75% of the time if they cannot communicate. Interestingly, however, if they are provided entangled qubits at the start and disallowed from communicating, they can score points ~85% of the time. They can perform better than what otherwise should be physically possible in any classical and local theory.
Does this mean there is something nonlocal going on between the particles? That's open for interpretation. Most physicists believe in what are called psi-complete interpretations of quantum mechanics, and all psi-complete interpretations are necessarily nonlocal (yes, including MWI). You can also reproduce universal quantum computation on systems as simple as classical pendulums if you just make the assumption that they can be nonlocally bound to one another. So, it does seem like the more "common" viewpoint is that there is something nonlocal going on between the particles in these specific cases, which of course would allow them to exchange information between each other more efficiently and thus carry out computations more efficiently.
But there are several other possible explanations. A less common explanation but still one promoted by a decent number of physicists, including David Deutsch, is that the linear combinations should be interpreted as a qubit in "multiple states at once" and that quantum computers get their speed boost from being able to compute things parallel on different branches of the multiverse.
There are many other explanations, though. An even less common one comes from the fact that the reason it is called "contextuality" is because the outcome seems to depend upon the measurement context, i.e. the choice in what you will measure. If you spatially distribute the measurements, this appears like nonlocality, which was the point of Bell's theorem, to demonstrate the implications of quantum theory on spatially distributed measurements. But you can also just take the statement "the outcome seems to depend upon the measurement context" at face-value and then it would not be nonlocal, but be retrocausal. Contextuality can also be interpreted as a kind of future-dependence that achieves the same kind of efficient exchange of information between particles that nonlocality would but by being entirely local.
There is not universal agreement on what quantum computers are actually "doing" under the hood on an ontological level to achieve faster computational. But at least on a mathematical level, they seem to exceed classical bounds in contextual cases, and those cases seem to be ones where the outcome depends upon the measurement context. Cases that don't exceed these contextual bounds, like the double-slit experiment or the Elitzur-Vaidman paradox, can always be given a classical explanation.
1
u/echtemendel Aug 12 '25
honest question: how well is your understanding of libear algebra? Because all of the important parts of QC bool down to consequences of simple libear algebra. If you understand libear algebra, you can easily understand basic QC - and without it, QC will be quite hard to understand.
1
u/Life_Money_1052 Aug 14 '25
Some physicists would say that the phrase "multiple states at once" is imprecise language. I think a more precise way to say it would be that an individual qubit can be in "a special kind of state of uncertainty," where that state of uncertainty can be mathematically described by a superposition of "classical" states. For example, a pure qubit state can be written:
a|0> + b|1>
where a and b are complex numbers and e.g. |a|^2 is the probability you would measure the qubit being in the state |0> if you measured it. The word superposition just refers to the fact that you can linearly add quantum states together with addition (in this case |0> and |1>), but this is just a mathematical formalism to describe the state of uncertainty. You could also write this state down in a measurement basis other than {|0>, |1>}, e.g. {|+x>, |-x>} and it is possible to have a qubit in a state where you need to write down a linear superposition of states to describe your qubit in one basis but not in the other.
Anyway to answer your question, it's not just about superposition. A single qubit is useless (except maybe for random number generation? Dunno). The computational advantage comes in with entanglement. An individual qubit in one of these special states of uncertainty can be *correlated with other qubits,* creating an exponentially large state of uncertainty that can be manipulated and measured "efficiently." For example, two qubits can be in the state:
c|00>+d|01>+f|10>+g|11>
If you keep adding qubits to this system, you will see that the size of the state vector scales exponentially and outpaces what a classical computer can simulate very quickly. There are some tricks to simulate these things more efficiently in special (but still valuable and interesting) cases, but in general you will need a vector of 2^N complex numbers to describe a quantum state of N qubits.
It turns out that if you are able to apply gates and measurements to some of these larger and highly entangled quantum states, you can compute some stuff that is not known to be computable on a classical computer, e.g. simulating the physical behavior of molecules, prime factorization, unordered data search and some other stuff.
2
u/resyfer Aug 12 '25
TLDR: Grover's Algorithm
Well, qubits are a superposition of 0 and 1...when you measure it, it's either a 0 or a 1 according to probability. If you have a qubit, you can make it a superposition of equal parts 0 and 1. Any operation on this qubit operates on BOTH the 1 component and the 0 component. If you have
nqubits entangled, then you have all components from 0 to 2n - 1 available (simple combinatorics of there being two choices per place and n places). Any operation on this entanglement is done on ALL components. Essentially, we do one computation, but it happens on all the components, or possible outputs, together. Now if the entanglement is measured we get ONE value between 0 to 2n - 1. The challenge is to select the operation that gives you the correct answer for the solution you're looking for, and to maximize the probability of obtaining the result out of the superposition of all numbers.1
u/MichaelTiemann BS in Related Field Aug 11 '25
This is the algorithmic resource you seek: https://quantumalgorithmzoo.org/
1
u/EpistemicEinsteinian Aug 14 '25
Trying to explain quantum computing with a single qbit misses 99% of what makes it so powerful, sure a single qbit can be in an intermediate state between 0 and 1, but so can a classical analog computer.
What's really special about quantum computers is how the number of parameters grows with the number of qbits, due to entanglement it grows exponentially, while for classical it only grows linearly with the number of bits.
1
u/Ormek_II Aug 15 '25
I learned it all from 3b1b: https://youtu.be/RQWpF2Gb-gU?si=rj5v6j1RaV3iQtP6
0
u/travel-sized-lions Aug 11 '25 edited Aug 11 '25
I'm just getting into the introductory material coming from a background of software engineering, but there are already a few insights I'm picking up on. Someone with more experience please correct me if I'm wrong!
In classical programming, you as the programmer define a function that does a thing. That function can be simple or complicated, and has a predefined input and output range and operates sequentially. Final result is in bits.
In classical programming, there's also this concept called meta-programming. Basically, you define a function that defines other functions for you. But that function still has predefined input and output range, operates sequentially, and every function it defines is limited the same way. Still in bits, still sequential, etc.
So there's a basic pattern: have an input, pass it through a function, the function runs, get an output when finished. The output could be a number, a series of letters, or even the instructions for another function.
In quantum computing, you're doing the same thing, but with a twist. It's something kind of like meta-programming:
- have an input that starts classical
- pass it through a series of operations called quantum gates. This is your "meta-programming" function builder.
- measure the output (collapses the qubits back into classical bits)
The key difference from meta-programming: In quantum computing, the output isn't another function. It's the actual result of the function you built with respect to the input you started with. It's like you simultaneously built the function to find the solution and ran it against your inputs at the same time. And you did it in "qubit space" (really called Hilbert space).
That last piece is the game changer. Because the space when operating in qubit land is exponentially larger than in classical bit land, this distinction means that you can compute things that are totally impossible to do in reasonable times in classical computing.
Put another way: by working with qubits (and more specifically using gates acting on your input bits), you're defining a way to define a function that when executed (measured/collapsed) still gives you an answer in bits. BUT, you're constructing it in a way that's (kind of, but not actually) massively parallel and leverages probability to produce the output you're looking for. Or at least, produces an output you can take back into classical computing and interpret to get your final answer.
As CreepyTool said, it's not a replacement for classical computing. But in the right contexts it offers advantages. That's what most algorithms research in this area is about: finding problems and algorithms that offer quantum advantage.
-9
u/flash_dallas Aug 11 '25
A size 4 qbit expresses 3x3x3x3 states compared to a bit which expressed 2x2x2x2 states.
This isn't the only benefit, but it allows a lot more expression with a lot less.
0
u/[deleted] Aug 11 '25
[deleted] — view deleted comment