Quantum States as Vectors

1. Why Complex Numbers?

In classical computing, a bit is simple: it's either 0 or 1. A qubit is more nuanced. To describe its state fully, we need more than just real numbers; we need complex numbers. They allow us to capture not just the probability of a qubit being 0 or 1, but also its phase, a uniquely quantum property we'll explore throughout this course.

Let's start with a quick, targeted refresher on the properties of complex numbers that are essential for quantum computing.

To summarize the key points from the video:

• A complex number $z$ has the form $z=a+ib$, where $a$ is the real part, $b$ is the imaginary part, and $i=\sqrt{-1}$.
• The complex conjugate of $z$, denoted $z^{\ast }$, is found by flipping the sign of the imaginary part: $z^{\ast }=a-ib$.
• The magnitude squared of a complex number, denoted $|z{|}^2$, is found by multiplying it by its conjugate: $$|z{|}^2=z^{\ast }z=(a-ib)(a+ib)=a^2-(ib{)}^2=a^2-i^2{b}^2=a^2+b^2$$

This last property is incredibly important, as we'll see that these "magnitudes squared" are directly related to probabilities.

2. The Statevector: A Qubit's Mathematical Identity

Now that we have complex numbers, how do we use them to describe a qubit? We use a statevector.

As the text explains, a quantum state vector for a single qubit is a 2-element column vector whose entries are complex numbers. The two key rules are:

1. The entries can be complex numbers.
2. The sum of the absolute values squared of the entries must be 1. This is called the normalization condition.

Let's make this concrete. A qubit has two fundamental states, analogous to the classical bit's 0 and 1. We call these basis states |0⟩ and |1⟩. (This |...⟩ notation is called ket notation, a handy shorthand we'll use from now on).

Their vector representations are:

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

You can think of the top entry as the complex amplitude for the |0⟩ state and the bottom entry as the amplitude for the |1⟩ state. For the |0⟩ state vector, it is "100% in the 0 state" and "0% in the 1 state", and vice-versa for the |1⟩ vector.

3. Superposition: Being in Both States at Once

What makes qubits powerful is that they are not limited to being just |0⟩ or |1⟩. They can be in a superposition of both. This is represented by a linear combination of the basis vectors.

Any generic single-qubit state |ψ⟩ can be written as:

Where $\alpha$ and $\beta$ are complex numbers representing the amplitudes. The normalization condition we learned earlier means that:

Let's see some examples.

Let's check the normalization for one of the examples from the reading, the |+⟩ state:

The normalization check is:

It works!

Now let's consider a state with a complex amplitude. For instance:

Is this a valid quantum state? Let's check the normalization.

• The magnitude squared of the first amplitude is $|1/\sqrt{2}{|}^2=1/2$.
• The magnitude squared of the second amplitude is $|i/\sqrt{2}{|}^2$. Using $z^{\ast }z$, this is $(-i/\sqrt{2})(i/\sqrt{2})=-i^2/2=-(-1)/2=1/2$.

So, the sum is $1/2+1/2=1$. Yes, it's a valid state.

4. A Glimpse into Qiskit

This might all seem a bit abstract, but it has a direct practical application in quantum programming frameworks like Qiskit. You don't have to run this code now (we'll set up your environment in a later module), but it's useful to see how the theory maps to code.

The following resource shows how to initialize a qubit state in Qiskit. Notice how it uses a simple list or array to represent the column vector we've been discussing.

As you can see, the vector [α, β] is exactly what you pass to the software to define a qubit's starting state. The article also mentions that Qiskit will raise an error if you provide a vector that isn't normalized. This shows how the mathematical rules we're learning are the very foundation of how these systems operate.

Conclusion

In this lesson, we've established the first and most important concept in quantum computation.

Key Takeaways:

• A qubit's state is described by a statevector, which is a 2-element column vector.
• The entries in the vector are complex numbers called amplitudes, written as $\left(\begin{array}{c}\alpha \\ \beta \end{array}\right)$.
• $\alpha$ is the amplitude for the |0⟩ state, and $\beta$ is the amplitude for the |1⟩ state.
• Statevectors must be normalized, meaning the sum of the squared magnitudes of their amplitudes must equal 1: $|\alpha {|}^2+|\beta {|}^2=1$.
• A state like $\alpha |0⟩+\beta |1⟩$ (where both $\alpha$ and $\beta$ are non-zero) is called a superposition.

Preview of the Next Lesson:
Now that we can describe a qubit's state, the next logical question is: how do we change it? In the next lesson, we will explore how quantum operations, or "gates," are represented by matrices. We will start by refreshing our understanding of matrix-vector multiplication, which is the mechanism for applying a gate to a qubit state.