Quantum Computing: The Future of Computation

The Suitcase Lock Problem

Suppose your suitcase has a 4-digit combination lock, each dial numbered 0 to 9. You have forgotten the code. If you try combinations one at a time — 0000, 0001, 0002, and so on — there are 10,000 possible combinations, so in the worst case you need 10,000 tries. A classical computer, no matter how fast, checks combinations the same way: one at a time, in sequence. It might do it a billion times a second, but it is still doing it one guess after another.

Now imagine a stranger kind of lock — one where, instead of turning the dials to a single guess, you could somehow set all four dials to try every one of the 10,000 combinations at once, and the lock itself would tell you, in a single check, which one worked. That is not science fiction wordplay. It is close to the real idea behind quantum computing: certain physical systems can hold many possibilities together and let them interact before you ever "look" at the answer. This chapter builds that idea from the ground up — honestly, with the real mathematics simplified but not faked, and with a clear line between what quantum computers can actually do today and what they cannot.

Recap: What a Classical Bit Really Is

Every computer you have used — your phone, your school's computer lab machine, the server that runs IRCTC's ticket booking — stores information as bits. A bit is a physical thing forced into one of two states: a transistor is either conducting or not, a tiny magnetic region points one way or the other, a voltage is either high or low. We label these two states 0 and 1. A byte is 8 bits, and 8 bits can represent exactly 2⁸ = 256 different patterns, one at a time. Crucially: at any given moment, a classical bit is 0, or it is 1. There is no in-between. This is the assumption quantum computing overturns — not by breaking physics, but by using a different kind of physical system to store information.

The Qubit: Built From Probability, Not Magic

A quantum bit, or qubit, is also a physical system — it might be the spin of an electron, the energy level of a superconducting loop cooled near absolute zero, or the polarization of a photon. But unlike a classical bit, a qubit does not have to commit to being 0 or 1 until you measure it. Before measurement, it exists in a superposition — a combination of the 0 possibility and the 1 possibility, described by two numbers called amplitudes.

Here is the misconception to clear up immediately, because almost every popular explanation gets it wrong: a qubit in superposition is not "secretly both 0 and 1 at the same time," like a coin frozen mid-flip. That phrase makes it sound like the qubit already has a hidden, definite value we just haven't looked at yet — but that is false, and physicists have experimentally ruled it out (through violations of what are called Bell inequalities, which is beyond this chapter's scope but is real, tested physics). What is actually true is closer to this: the qubit's state is a mathematical description of tendencies — a recipe that says "when you finally do measure this qubit, here is the probability you'll get 0, and here is the probability you'll get 1." Until measurement happens, asking "which one is it really?" is not a question with an answer — the system genuinely hasn't decided.

Writing Superposition With Numbers

Physicists write a qubit's state using a notation called a ket: |0⟩ means "the pure 0 state" and |1⟩ means "the pure 1 state." A qubit in superposition is written as a combination:

|ψ⟩ = α|0⟩ + β|1⟩

Here alpha (α) and beta (β) are the amplitudes — numbers attached to each possibility. The rule connecting amplitudes to real-world probability is: probability of measuring 0 equals α², and probability of measuring 1 equals β². Because you must get some result when you measure, these probabilities always add up to 1: α² + β² = 1. (In the full theory α and β can be complex numbers, which is what allows the interference effects that make quantum algorithms powerful. For this chapter, our worked examples use plain positive real numbers, which is enough to see the core ideas correctly.)

Let's make this concrete with the most important single-qubit operation in quantum computing, the Hadamard gate. Applied to a qubit that starts as a definite 0, it produces the state:

|ψ⟩ = (1/√2)|0⟩ + (1/√2)|1⟩

Let's check this obeys the rule. 1/√2 ≈ 0.707. Squaring it: (1/√2)² = 1/2 = 0.5. So the probability of measuring 0 is 0.5, and the probability of measuring 1 is 0.5. They add to 1, as required. This is a perfectly balanced 50/50 superposition — the quantum equivalent of a fair coin, except the "coin" genuinely has no outcome yet, only these two probabilities, until you measure it.

Measurement Collapses the Superposition

Measurement is the one place where quantum mechanics behaves unlike anything in classical computing: the act of measuring a qubit forces it to commit to exactly one classical value, 0 or 1, chosen randomly according to the probabilities above — and the superposition is destroyed in the process. If you immediately measured the same physical qubit again, you would get the same answer again, because it is now sitting in a definite state. You cannot "peek" at a superposition without collapsing it; there is no way to read out α and β directly from a single qubit.

The diagram below shows this whole story for our Hadamard example: a qubit starts in superposition with 50% weight on each outcome, and a measurement collapses it into one classical result.

Try It: Simulating This on a Real Quantum Programming Toolkit

You do not need physical quantum hardware to explore this — companies like IBM provide free cloud access and open-source simulators. Here is real, valid Qiskit (IBM's Python quantum computing library) code that builds exactly the circuit we just traced by hand:

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(1, 1)   # 1 qubit, 1 classical bit to store the result
qc.h(0)                     # Hadamard gate: puts qubit 0 into equal superposition
qc.measure(0, 0)            # measure qubit 0, store result in classical bit 0

sim = AerSimulator()
result = sim.run(qc, shots=1000).result()
print(result.get_counts())

Tracing this line by line: QuantumCircuit(1, 1) creates one qubit (starting, by default, in the |0⟩ state) and one classical register bit to hold the measurement outcome. qc.h(0) applies the Hadamard gate to qubit 0, producing the superposition we calculated above. qc.measure(0, 0) collapses the qubit and writes 0 or 1 into the classical bit. Running this circuit 1,000 times (shots=1000) and printing the counts will show a dictionary close to {'0': 500, '1': 500} — never exactly 500/500 every run, because each shot is a genuinely random event, but reliably close to a 50/50 split over many shots, exactly matching the probabilities α² and β² we computed by hand.

Why More Qubits Change Everything: Exponential Scaling

The real power of quantum computing does not come from one qubit — it comes from combining many. With classical bits, 2 bits can be in one of 4 possible patterns (00, 01, 10, 11) at a time, and n bits give you one of 2ⁿ patterns, but only one at a time. With qubits, n qubits in superposition can hold amplitudes for all 2ⁿ patterns simultaneously — one complex number attached to every single one of those 2ⁿ combinations. Three qubits, for example, carry amplitudes for all 8 patterns at once: 000, 001, 010, 011, 100, 101, 110, 111.

This growth is exponential, and exponential growth is deceptive because it starts small and then explodes. The chart below shows how the count of simultaneously-held states grows as you add qubits — notice how quickly the numbers on top of the bars outrun the gentle, steady growth of the bar heights (which are drawn on a compressed, "one qubit at a time" scale so the chart actually fits on the page):

Ten qubits already juggle 1,024 states at once — more than a 3-digit decimal number's worth of possibilities held in superposition together. Push this further: 20 qubits give 2²⁰ = 1,048,576 states, over a million. Around 300 qubits would carry amplitudes for roughly 2³⁰⁰ states — a number larger than the estimated number of atoms in the observable universe (around 10⁸⁰). No classical supercomputer, no matter how large, could even store a description of that many simultaneous amplitudes in memory. This is the mathematical seed of quantum advantage — and, just as importantly, of the immense engineering difficulty of building these machines, since every one of those qubits must stay coherent (undisturbed by heat, vibration, or stray electromagnetic noise) for the calculation to mean anything.

Entanglement: Correlated, Not Connected

Superposition describes one qubit. Entanglement describes a special relationship between two or more qubits, where their outcomes become linked in a way that has no classical explanation. Consider two qubits prepared in this specific two-qubit superposition (called a Bell state):

|ψ⟩ = (1/√2)|00⟩ + (1/√2)|11⟩

Squaring the amplitudes as before: there is a 50% chance of measuring "00" (both qubits are 0) and a 50% chance of measuring "11" (both qubits are 1). Notice what is completely missing: "01" and "10" have zero amplitude, so they can never happen. If you measure the first qubit and get 0, you know with certainty — instantly — that the second qubit, wherever it physically is, will also read 0 if measured. If you get 1, the second is guaranteed to be 1 too. The two qubits are entangled: their individual outcomes are random, but they are perfectly correlated with each other.

Common misconception, and an important one: many descriptions of entanglement imply it lets you send information instantly across any distance, faster than light. This is false, and it is not a minor simplification — it is a genuine physics result called the no-communication theorem. Here is why: the person holding the first qubit gets a completely random result (50% chance of 0, 50% chance of 1) no matter what happens to the second qubit. They cannot choose or control which outcome they get, so they cannot use their random result to send a chosen message. The correlation is only visible after both people compare notes through an ordinary, classical channel — a phone call, an email — which travels no faster than light. What entanglement gives quantum computers is not faster messaging; it is a resource for computation, letting algorithms coordinate outcomes across many qubits in ways with no classical counterpart.

Quantum Gates and Circuits

Just as classical circuits are built from logic gates like AND, OR, and NOT, quantum circuits are built from quantum gates — mathematical operations that rotate and mix the amplitudes of qubits while always preserving the rule that all probabilities add up to 1. The Hadamard gate (H) we already used creates superposition from a definite state. Other common gates include the Pauli-X gate (a quantum version of NOT, flipping |0⟩ and |1⟩), and the CNOT (controlled-NOT) gate, which acts on two qubits and is the standard way to create entanglement: it flips a "target" qubit only when a "control" qubit is |1⟩, and applying it to a control qubit already in Hadamard superposition produces exactly the Bell state shown above. A quantum algorithm is simply a sequence of these gates applied to a starting set of qubits, followed by a measurement at the end — conceptually similar to a classical circuit diagram, except the "wires" carry amplitudes instead of fixed 0s and 1s until the final measurement.

Why a Quantum Computer Is Not Just "A Faster Computer"

Common misconception: that quantum computers are a general upgrade — the next generation of laptop, faster at everything the way an SSD is faster than a hard disk. This is incorrect, and it matters for understanding where this technology is actually headed. Quantum speedups are known for a specific, limited set of problems: searching unsorted data, factoring large numbers, simulating quantum-mechanical systems (like molecules for drug design), and a handful of optimization problems. For the vast majority of everyday computing — browsing a website, running a spreadsheet, playing a video, even most database lookups on already-sorted data — classical computers remain faster, cheaper, and far more reliable, and there is no known quantum algorithm that would help. Quantum computers are best understood as specialized co-processors for narrow problem classes, not replacements for the device you are reading this on.

Two Algorithms That Matter

Grover's algorithm answers our opening suitcase-lock problem directly. Searching an unsorted collection of N items classically requires checking items one by one: on average N/2 checks, and N in the worst case. Grover's algorithm, running on a quantum computer, finds the answer using roughly √N steps — a quadratic speedup. For our suitcase lock, N = 10,000, so √N = 100: a hundred quantum steps instead of thousands of classical guesses. Scale it up: for a database of N = 1,000,000 unsorted records, classical search needs about 500,000 checks on average; Grover's algorithm needs on the order of √1,000,000 = 1,000 steps (the precise optimal count from the algorithm's exact formula, (π/4)√N, works out to roughly 785 — the key point is the scaling, not the last digit). That is a real, provable, and enormous advantage for this specific kind of problem.

Shor's algorithm is more dramatic still: it factors large numbers into their prime components exponentially faster than the best known classical methods. This matters immensely for cybersecurity, because the most widely used public-key encryption scheme, RSA — which secures banking logins, UPI transactions, and HTTPS websites — relies entirely on the fact that factoring a very large number (hundreds of digits) is practically impossible for classical computers within a human lifetime. A sufficiently large, error-corrected quantum computer running Shor's algorithm could break this in a reasonable time. This is not yet a practical threat — today's quantum hardware is far too small and too error-prone to factor numbers of that size — but it is real enough that cryptographers worldwide are already standardizing new "post-quantum" encryption methods designed to resist even a future quantum computer.

Where Quantum Computing Actually Stands Today

It is easy to come away from headlines thinking quantum computers already outperform classical ones broadly. The honest picture is more modest. Today's machines are in what physicist John Preskill named the NISQ era — Noisy Intermediate-Scale Quantum — meaning they have a meaningful but still limited number of qubits, and those qubits are fragile: heat, vibration, and stray electromagnetic fields constantly introduce errors, a problem called decoherence. Building qubits that stay reliably coherent long enough, and correcting their errors faster than they accumulate, remains the central engineering challenge of the field.

In 2019, Google's 53-qubit Sycamore processor ran a specific, narrowly defined sampling task in about 200 seconds, which Google's team estimated would take roughly 10,000 years on the world's fastest classical supercomputer at the time — a milestone they called "quantum supremacy." IBM researchers disputed the comparison, arguing a classical supercomputer with enough storage could complete the same task in about two and a half days rather than millennia, and subsequent research found even better classical methods for that particular benchmark. The honest lesson is not that the claim was worthless, but that comparisons between quantum and classical performance are genuinely difficult, contested by experts, and specific to narrow tasks — not evidence of a general quantum advantage over classical computing.

Different companies are pursuing different physical designs for qubits. IBM and Google build superconducting-circuit qubits, cooled to near absolute zero; by the early 2020s IBM had built chips exceeding a thousand physical qubits. IonQ and Quantinuum build trapped-ion qubits, using individual charged atoms held by electric fields. Other groups explore photonic qubits (using particles of light) and neutral-atom qubits. None of these approaches has yet produced a large-scale, fully error-corrected quantum computer — that remains a future milestone, likely years to decades away, not a solved problem.

India is investing directly in this field through the National Quantum Mission, approved by the Union Cabinet in April 2023 with an outlay of about ₹6,003 crore over eight years (2023–2031), run by the Department of Science and Technology. The mission funds research hubs across leading institutions, including IISc Bengaluru and several IITs, and aims to help India build quantum computers with tens to a few thousand physical qubits over the mission's span, alongside work on quantum communication and quantum sensing. Indian deep-tech startups such as Bengaluru-based QpiAI have also begun building quantum computing hardware and software as part of this growing ecosystem — a reminder that this is not only a story about American and European labs.

Check Your Understanding

1. A qubit has amplitudes α = 0.6 and β = 0.8 for |0⟩ and |1⟩. Verify this is a valid quantum state, and state the probability of measuring 1.
2. Explain, in your own words, why "a qubit is both 0 and 1 at the same time" is a misleading way to describe superposition. What is more accurate?
3. Two qubits are entangled in the Bell state (1/√2)|00⟩ + (1/√2)|11⟩. If a friend on the Moon measures their qubit and gets 1, what do you instantly know about the other qubit on Earth — and why does this not violate the speed-of-light limit on communication?
4. A company has an unsorted customer database with 4,000,000 records. Estimate how many checks classical linear search needs on average, and roughly how many steps Grover's algorithm would need on a quantum computer.
5. Why is it inaccurate to describe a quantum computer as simply "a faster version of a normal computer"? Name one class of problem where it would not help at all.

Answers: (1) 0.6² + 0.8² = 0.36 + 0.64 = 1.00, so it is valid; probability of measuring 1 is 0.8² = 0.64, or 64%. (2) It is misleading because it implies a hidden, already-decided value; more accurately, the qubit's state encodes probabilities for each outcome, and no definite value exists until measurement. (3) You instantly know the Earth qubit will also read 1 if measured — but you cannot use this to send a message, because each person's individual result is random and uncontrollable; the correlation is only useful once compared over an ordinary, light-speed-limited channel. (4) Classical: about 2,000,000 checks on average; Grover's: roughly √4,000,000 = 2,000 steps. (5) Quantum speedups apply only to specific problem types (search, factoring, quantum simulation, some optimization); for tasks like everyday word processing or browsing, there is no known quantum algorithm that helps, so classical computers remain the right tool.

Summary

• A classical bit is always definitely 0 or 1; a qubit before measurement holds amplitudes α and β for both, with probabilities α² and β² that must sum to 1.
• Measurement collapses a qubit's superposition into one definite classical result, chosen randomly according to those probabilities — you cannot read out α and β directly.
• n qubits can hold amplitudes for all 2ⁿ possible combinations simultaneously, an exponential resource with no classical equivalent — but also exponentially hard to keep stable (decoherence).
• Entanglement links the measurement outcomes of separate qubits with correlations stronger than anything classical physics allows, but it cannot be used to send information faster than light.
• Quantum gates (Hadamard, Pauli-X, CNOT) manipulate qubit amplitudes; sequences of gates followed by measurement form quantum circuits, the quantum analogue of classical logic circuits.
• Grover's algorithm gives a quadratic (√N) speedup for unstructured search; Shor's algorithm gives an exponential speedup for factoring, threatening RSA encryption and motivating new post-quantum cryptography standards.
• Quantum computers are not general replacements for classical computers — they help with a narrow set of problems, and today's hardware is still in the noisy, error-prone NISQ era. India's National Quantum Mission (2023–2031, ~₹6,003 crore, Department of Science and Technology) is one of the national efforts pushing this frontier forward.