Representing Multi-Qubit Systems with Tensor Products

Hello! Welcome back to our course on linear algebra for quantum mechanics and deep learning.

In the last lesson, we introduced the crucial distinction between separable and entangled states. We saw that while we build composite systems using the tensor product, not all states in the resulting space can be factored back into their individual components. This concept of entanglement, where parts of a system are intrinsically linked, is a cornerstone of quantum mechanics.

Today, we will build directly on that foundation. Our goal is to formalize the process of describing multi-qubit systems. You'll learn how to systematically construct the "computational basis"—the standard set of reference states for a multi-qubit system—and how to represent any possible state, whether separable or entangled, within that framework.

This lesson directly addresses your goal of understanding quantum mechanics, as representing multi-particle states is a fundamental requirement.

Learning Outcome: Apply tensor products to represent the states of a multi-qubit system.

1. Constructing the Two-Qubit Basis

Let's begin by solidifying our understanding of the simplest composite quantum system: two qubits. We know from our previous work that a single qubit's state space $C^{2}$ has the standard basis states:

∣0 ⟩ = (10) and ∣1 ⟩ = (01)

To describe a two-qubit system, we use the tensor product to combine their state spaces: $C^{2} \otimes C^{2}$ , which results in a four-dimensional space, $C^{4}$ . How do we form a basis for this new space? We do it by taking the tensor product of the basis vectors from the individual spaces.

The following video provides a clear, step-by-step guide to constructing the computational basis for a two-qubit system. It will walk you through the mechanics of the Kronecker product for column vectors, which is the concrete calculation behind the abstract tensor product.

2-Qubit Computational Basis States, Tensor Products, Orthonormality, 4D Hilbert Space

This video, '2-Qubit Computational Basis States...', from the Elucyda channel clearly demonstrates the process of building the standard basis for a two-qubit system.

Please watch from the beginning to 07:30. The video will first recap the single-qubit basis states and then show the general rule for taking the tensor product of two column vectors. Pay close attention to how this rule is applied to the single-qubit basis states |0⟩ and |1⟩ to create the four two-qubit basis states: |00⟩, |01⟩, |10⟩, and |11⟩, along with their 4x1 column vector representations.

As the video demonstrates, the four computational basis states for a two-qubit system are:

State $∣00 ⟩$ : Both qubits are in the $∣0 ⟩$ state. $∣00 ⟩ = ∣0 ⟩ \otimes ∣0 ⟩ = (10) \otimes (10) = 1 (10) 0 (10) = 1000$
State $∣01 ⟩$ : The first qubit is $∣0 ⟩$ , the second is $∣1 ⟩$ . $∣01 ⟩ = ∣0 ⟩ \otimes ∣1 ⟩ = (10) \otimes (01) = 1 (01) 0 (01) = 0100$
State $∣10 ⟩$ : The first qubit is $∣1 ⟩$ , the second is $∣0 ⟩$ . $∣10 ⟩ = ∣1 ⟩ \otimes ∣0 ⟩ = (01) \otimes (10) = 0 (10) 1 (10) = 0010$
State $∣11 ⟩$ : Both qubits are in the $∣1 ⟩$ state. $∣11 ⟩ = ∣1 ⟩ \otimes ∣1 ⟩ = (01) \otimes (01) = 0 (01) 1 (01) = 0001$

These four vectors form an orthonormal basis for the $C^{4}$ space of the two-qubit system. Notice the ordering convention: the string inside the ket, like '10', corresponds to the binary number 2, and the vector $∣10 ⟩$ has a '1' in the position with index 2 (if we start indexing from 0). This pattern is very useful.

2. Generalizing to N-Qubit Systems

The real power of this framework is its scalability. While combining two qubits gives a 4D space, what about three, four, or n qubits?

The pattern continues: the state of an n-qubit system is described by a vector in a $2^{n}$ -dimensional complex Hilbert space. This exponential growth is a defining feature of quantum computation and is what gives it its immense potential power. The following reading selection formalizes this generalization.

1-3. Multiqubit representation

The video showed us how to handle two qubits. Now, let's generalize this to any number of qubits. The Qulacs Dojo documentation, '1-3. Multiqubit representation', provides an excellent, concise explanation.

Please read the introductory section (up to 'Example: 2 quantum bits case') and the section 'Calculating Tensor Products'. Focus on the key takeaway: an n-qubit system requires a 2^n dimensional complex vector. Also, pay attention to the rule for calculating the tensor product in column vector form shown in the second section.

Any State as a Superposition

Just as any single-qubit state can be written as $α ∣0 ⟩ + β ∣1 ⟩$ , any n-qubit state can be written as a linear combination (a superposition) of all $2^{n}$ computational basis states.

For a two-qubit system, a general state $∣Ψ ⟩$ is:

∣Ψ ⟩ = c_{00} ∣00 ⟩ + c_{01} ∣01 ⟩ + c_{10} ∣10 ⟩ + c_{11} ∣11 ⟩ = c_{00} c_{01} c_{10} c_{11}

where the complex coefficients $c_{ij}$ must satisfy the normalization condition $\sum_{i, j \in {0, 1}} ∣ c_{ij} ∣^{2} = 1$ .

For an n-qubit system, this becomes:

∣Ψ ⟩ = i_{1}, \dots, i_{n} \in {0, 1} \sum c_{i_{1} i_{2} \dots i_{n}} ∣ i_{1} i_{2} \dots i_{n} ⟩

It's also useful to know that different notations are often used interchangeably: $∣ i_{1} i_{2} ⟩$ , $∣ i_{1} ⟩ ∣ i_{2} ⟩$ , and $∣ i_{1} ⟩ \otimes ∣ i_{2} ⟩$ all represent the same tensor product state.

3. Worked Examples

Let's put this into practice to solidify the concepts.

Example 1: Constructing a 3-Qubit Basis State

Let's find the 8D column vector for the basis state $∣101 ⟩$ .

We need to compute $∣1 ⟩ \otimes ∣0 ⟩ \otimes ∣1 ⟩$ . The tensor product is associative, so we can group it as $∣1 ⟩ \otimes (∣0 ⟩ \otimes ∣1 ⟩)$ .

First, compute the inner product:
$∣0 ⟩ \otimes ∣1 ⟩ = ∣01 ⟩ = 0100$
Now, compute the outer product:
$∣1 ⟩ \otimes ∣01 ⟩ = (01) \otimes 0100 = 0 \cdot 0100 1 \cdot 0100 = 00000100$

This is an 8-dimensional vector with a 1 in the position with index 5 (since binary 101 is 5). This confirms the ordering rule we observed earlier.

Example 2: Representing a Separable State

In the last lesson's exercise, we found that the state $∣Ψ ⟩ = \frac{1}{2} (∣0 ⟩ + ∣1 ⟩) \otimes \frac{1}{2} (∣0 ⟩ - ∣1 ⟩)$ was separable. Let's find its column vector representation.

First, write the individual state vectors:
$∣ ψ ⟩ = \frac{1}{2} (∣0 ⟩ + ∣1 ⟩) = \frac{1}{2} (11) and ∣ ϕ ⟩ = \frac{1}{2} (∣0 ⟩ - ∣1 ⟩) = \frac{1}{2} (1 - 1)$
Now, compute their tensor product:
$∣Ψ ⟩ = ∣ ψ ⟩ \otimes ∣ ϕ ⟩ = (\frac{1}{2})^{2} (11) \otimes (1 - 1) = \frac{1}{2} 1 (1 - 1) 1 (1 - 1) = \frac{1}{2} 1 - 1 1 - 1$

This column vector is the complete representation of our state $∣Ψ ⟩$ . If we expand it in the computational basis, we get $\frac{1}{2} (∣00 ⟩ - ∣01 ⟩ + ∣10 ⟩ - ∣11 ⟩)$ , matching the exercise from last time.

Test your understanding!

The GHZ (Greenberger-Horne-Zeilinger) state is a famous 3-qubit entangled state defined as:
$∣ GHZ ⟩ = \frac{1}{2} (∣000 ⟩ + ∣111 ⟩)$
Write down the 8-dimensional column vector that represents this state.

Show answer

To find the vector for $∣ GHZ ⟩$ , we need to find the vectors for the basis states $∣000 ⟩$ and $∣111 ⟩$ and then add them, scaling by $1/ 2$ .

Vector for $∣000 ⟩$ : This is the state where the bitstring is 000, which corresponds to index 0. The vector is all zeros except for a 1 in the first position.
$∣000 ⟩ = 10000000$
Vector for $∣111 ⟩$ : The bitstring is 111, which is 7 in decimal. This corresponds to index 7 (the last position). The vector is all zeros except for a 1 in the last position.
$∣111 ⟩ = 00000001$
Combine them:
$∣ GHZ ⟩ = \frac{1}{2} 10000000 + 00000001 = \frac{1}{2} 10000001 = 1/ 2 000000 1/ 2$

Conclusion

In this lesson, we established the standard procedure for representing the state of a multi-qubit system. We've seen how the tensor product provides the mathematical machinery to combine single-qubit states into a much larger, exponentially growing state space.

Key Takeaways:

An n-qubit system is described by a state vector in a $2^{n}$ -dimensional complex Hilbert space.
The computational basis for this space consists of all $2^{n}$ possible tensor products of the single-qubit basis states $∣0 ⟩$ and $∣1 ⟩$ , denoted as $∣ i_{1} i_{2} \dots i_{n} ⟩$ .
Any n-qubit state can be expressed as a linear combination (superposition) of these basis states.
The Kronecker product is the concrete algorithm for computing the tensor product of column vectors, allowing us to find the vector representation for any multi-qubit state.

Preview of the Next Lesson:

We have now defined states for both single and multiple qubits. The next logical step is to define the operations that act on these multi-qubit states. In the next lesson, we will learn how to apply the tensor product to linear operators, allowing us to construct the matrix representation of gates that act on multi-qubit systems, such as the crucial CNOT gate.

Recommended resources