Superposition and Qubits

From Classical Bits to Quantum Bits

In classical computing, information is encoded in bits. A bit is the simplest possible unit of information, representing a system that can be in one of two distinct states, which we label 0 and 1. Think of a light switch: it is either on or off. There is no in-between.

A quantum bit, or qubit, is the quantum analogue. It also has two fundamental states, which we call basis states, corresponding to the classical 0 and 1. However, thanks to the principle of superposition, a qubit can exist in a combination of both states at the same time.

This is not the same as classical uncertainty. If you flip a coin and cover it without looking, you are in a state of uncertainty—you simply don't know if it's heads or tails. But the coin itself has a definite state. Superposition is fundamentally different. A qubit in a superposition has not yet "decided" whether it is a 0 or a 1; it is physically in a blend of both possibilities.

To understand this distinction more deeply, let's turn to a clear explanation.

Describing the State of a Qubit

Since you have a strong background in linear algebra, you'll find the mathematical description of a qubit quite natural. The state of a qubit is not just a number, but a vector. This "state vector" lives in a two-dimensional complex vector space.

For a single qubit, the two basis states are represented by orthogonal unit vectors:

• The state $|0⟩$ is represented by the vector $\left(\begin{array}{c}1\\ 0\end{array}\right)$.
• The state $|1⟩$ is represented by the vector $\left(\begin{array}{c}0\\ 1\end{array}\right)$.

(The $|\cdot ⟩$ notation is called Dirac or "ket" notation, which we will formalize in the next lesson. For now, just think of $|0⟩$ and $|1⟩$ as labels for our two basis vectors.)

A qubit in a superposition is described by a linear combination of these basis vectors. The following video by 3Blue1Brown provides one of the best explanations available for the state vector and its connection to measurement.

As the video explained, a general state of a qubit, which we can call $|\psi ⟩$, is a unit vector written as:

The numbers $\alpha$ and $\beta$ are called amplitudes. They are, in general, complex numbers. The fundamental rule connecting this state vector to the physical world is that the probability of measuring the qubit and finding it in state $|0⟩$ is $|\alpha {|}^2$, and the probability of finding it in state $|1⟩$ is $|\beta {|}^2$. Because the total probability must be 1, the amplitudes must satisfy the normalization condition: $|\alpha {|}^2+|\beta {|}^2=1$. This is why the state vector is a unit vector.

Let's read a short section that reinforces this mathematical formulation.

Creating and Using Superposition

A crucial point is that superposition is not a random accident; it is a state we can create and manipulate with precision using quantum gates. These are the quantum equivalents of classical logic gates like AND, OR, and NOT.

The most fundamental gate for creating superposition is the Hadamard gate, denoted by $H$. When applied to a qubit in the $|0⟩$ state, it transforms it into an equal superposition of $|0⟩$ and $|1⟩$.

In this state, the amplitudes are $\alpha =\beta =1/\sqrt{2}$. When we measure this qubit, the probability of getting 0 is $|1/\sqrt{2}{|}^2=1/2$, and the probability of getting 1 is also $|1/\sqrt{2}{|}^2=1/2$. The qubit has a 50/50 chance of collapsing to either classical state.

Implication: Quantum Parallelism

So, why is this useful? The true power emerges when we consider a system of multiple qubits. A system with $n$ classical bits can be in only one of $2^n$ possible states at any given time. However, a system of $n$ qubits can exist in a superposition of all $2^n$ states simultaneously.

For example, with 2 qubits, we can create a state like:

This state is a simultaneous representation of all four possible 2-bit strings. If we apply a quantum gate that computes a function, it acts on all parts of the superposition at once. This is the essence of quantum parallelism.

However, it is crucial to avoid a common misconception. A quantum computer does not simply try all solutions in parallel and then magically spit out the correct one. When you measure the final state, the superposition collapses, and you only get one of the $2^n$ possible outcomes. The art of quantum algorithm design is to use interference—the topic of our last lesson—to choreograph the evolution of these amplitudes so that the paths leading to incorrect answers cancel each other out, while the paths leading to the correct answer reinforce each other.

Conclusion

In this lesson, we have moved from the physical picture of wave-particle duality to the computational framework of qubits and superposition.

Here are the key takeaways:

• Superposition is a fundamental quantum principle where a system, like a qubit, can exist in a linear combination of multiple distinct states simultaneously.
• A qubit is the quantum version of a bit. Its state is described by a state vector $|\psi ⟩=\alpha |0⟩+\beta |1⟩$, where $\alpha$ and $\beta$ are complex amplitudes.
• Upon measurement, the superposition collapses to a classical state ($|0⟩$ or $|1⟩$) with probabilities given by the squared magnitudes of the amplitudes ($|\alpha {|}^2$ and $|\beta {|}^2$).
• Superposition enables quantum parallelism, where a quantum computer can perform operations on an exponential number of states at once. However, this power can only be harnessed by using quantum interference to make the desired result probable.

We have informally used the $|\psi ⟩$ notation throughout this lesson. In our next session, we will delve deeper into this powerful mathematical language, Dirac notation, and use it to formally represent single qubit states and their transformations on the Bloch sphere.