Tensor Products for Multi-Qubit Operators

Hello! Welcome back to our journey through linear algebra for quantum mechanics and deep learning.

In the last lesson, we learned how to represent the states of multi-qubit systems. We saw that an n-qubit system lives in a $2^{n}$ -dimensional Hilbert space, and any state can be written as a superposition of $2^{n}$ basis vectors like $∣ i_{1} i_{2} \dots i_{n} ⟩$ .

Today, we'll address the other side of the coin: the operators that act on these multi-qubit states. Just as we used the tensor product to build larger state vectors from smaller ones, we will now use it to build larger operator matrices. This will allow us to describe multi-qubit quantum gates, which are the building blocks of quantum algorithms.

Our focus will be on one of the most important two-qubit gates: the Controlled-NOT (CNOT) gate. Understanding its representation is a crucial step toward your goal of studying quantum mechanics.

Learning Outcome: Apply tensor products to represent operators on a multi-qubit system, such as the CNOT gate.

1. The Tensor Product of Operators

Imagine a two-qubit system. We might want to apply operator $A$ to the first qubit and operator $B$ to the second qubit. How do we find a single matrix that represents this combined operation?

The answer lies in the tensor product of the matrices for $A$ and $B$ . The resulting operator $C = A \otimes B$ is a larger matrix that acts on the composite state space. The key property that defines this new operator is:

(A \otimes B) (v \otimes w) = (A v) \otimes (B w)

This elegant rule says that applying the tensor product operator is the same as applying each individual operator to its respective vector and then taking the tensor product of the results.

To see how this is constructed, please read the following brief explanation. It provides the crucial link between the desired property above and the resulting matrix structure.

Module 4: Quantum Linear Algebra, Part 2

The following text, 'Tensor products of operators' from Prof. Rahul Simha's notes, provides an excellent derivation for the tensor product of two matrices.

Please read the section '4.3 Tensor products of operators'. Focus on the derivation that starts with the goal C(v⊗w) = Av⊗Bw and ends with the block matrix definition of C = A⊗B. This is the 'why' behind the Kronecker product for matrices.

As the text shows, if $A$ is an $m \times m$ matrix and $B$ is an $n \times n$ matrix, their tensor product $A \otimes B$ is an $(mn) \times (mn)$ block matrix:

A \otimes B = a_{11} B a_{21} B ⋮ a_{12} B a_{22} B ⋮ \dots \dots ⋱

This is the Kronecker product applied to matrices, which you've already seen for vectors. Let's watch a quick video that shows a concrete calculation.

Quantum Computing: Dirac's Bra-Ket Notation and Tensor Product

This clip from the 'Advanced Maths' channel will visualize the calculation of a tensor product of two simple matrices.

Please watch from 14:40 to 16:49. Notice how each scalar element of the first matrix 'A' multiplies the entire second matrix 'B' to form a block in the final, larger matrix.

2. The Controlled-NOT (CNOT) Gate

The CNOT gate is a cornerstone of quantum computing. It's a two-qubit gate that performs a conditional operation. It has a control qubit and a target qubit. The logic is simple:

If the control qubit is in the state $∣0 ⟩$ , it does nothing to the target qubit.
If the control qubit is in the state $∣1 ⟩$ , it flips the target qubit (applies an $X$ , or NOT, gate).

Let's look at its standard representations.

CNOT Gate: Matrix and Circuit Representation — The CNOT gate, showing its 4x4 matrix and its circuit diagram. The filled circle is the control qubit, and the circled plus is the target. Here, the first qubit is the control.

The matrix acts on the 4D state vector of the two-qubit system. Let's verify its action on the computational basis states $∣00 ⟩, ∣01 ⟩, ∣10 ⟩, ∣11 ⟩$ . Remember their vector forms: $∣00 ⟩ = [1, 0, 0, 0]^{T}$ , $∣01 ⟩ = [0, 1, 0, 0]^{T}$ , etc.

Input $∣10 ⟩$ : Control is $∣1 ⟩$ , target is $∣0 ⟩$ . We expect the target to flip, yielding $∣11 ⟩$ . $10000100000100100010 = 0001 \to ∣11 ⟩$
Input $∣11 ⟩$ : Control is $∣1 ⟩$ , target is $∣1 ⟩$ . We expect the target to flip, yielding $∣10 ⟩$ .

CNOT Gate Operation on |11⟩ State — A circuit diagram showing the CNOT gate transforming the input state |11⟩ to the output state |10⟩.

This matrix representation is correct, but for your goals in quantum mechanics, there is a more insightful way to represent it.

CNOT as a Sum of Tensor Products

We can express the CNOT's logic—"IF control is 0, DO Identity; IF control is 1, DO NOT"—using operators. In quantum mechanics, an "if" condition on a basis state like $∣0 ⟩$ can be implemented with a projector, $∣0 ⟩ ⟨ 0∣$ .

This leads to a beautiful construction of the CNOT operator:

CNOT = If control is ∣0 ⟩, do nothing to target (∣0 ⟩ ⟨ 0∣ \otimes I) + If control is ∣1 ⟩, flip the target (∣1 ⟩ ⟨ 1∣ \otimes X)

Here, $∣0 ⟩ ⟨ 0∣$ and $∣1 ⟩ ⟨ 1∣$ are projectors acting on the first (control) qubit, while $I$ (Identity) and $X$ (Pauli-X/NOT) act on the second (target) qubit.

Let's verify this form gives the same 4x4 matrix. We need the matrices for the single-qubit operators:

∣0 ⟩ ⟨ 0∣ = (10) (10) = (1000) ∣1 ⟩ ⟨ 1∣ = (01) (01) = (0001)

I = (1001) X = (0110)

Now, we compute the tensor products:

∣0 ⟩ ⟨ 0∣ \otimes I = (1000) \otimes I = (1 \cdot I 0 \cdot I 0 \cdot I 0 \cdot I) = 1000010000000000

∣1 ⟩ ⟨ 1∣ \otimes X = (0001) \otimes X = (0 \cdot X 0 \cdot X 0 \cdot X 1 \cdot X) = 0000000000010010

Adding these two matrices together gives us exactly the CNOT matrix we saw earlier. This powerful outer-product representation is used frequently in quantum mechanics literature.

Test your understanding!

Using the outer-product form, construct the 4x4 matrix for a "reversed" CNOT gate, where the second qubit is the control and the first qubit is the target. The logic is: "If the second qubit is $∣1 ⟩$ , flip the first qubit."

Show answer

The logic translates to:

CNOT_{rev} = I \otimes ∣0 ⟩ ⟨ 0∣ + X \otimes ∣1 ⟩ ⟨ 1∣

Notice the operators are swapped because $I$ and $X$ now act on the first qubit, while the projectors act on the second. Let's compute the matrix:

I \otimes ∣0 ⟩ ⟨ 0∣ = (1 \cdot ∣0 ⟩ ⟨ 0∣ 0 0 1 \cdot ∣0 ⟩ ⟨ 0∣) = 1000000000100000

X \otimes ∣1 ⟩ ⟨ 1∣ = (0 1 \cdot ∣1 ⟩ ⟨ 1∣ 1 \cdot ∣1 ⟩ ⟨ 1∣ 0) = 0000010000000001 \leftarrow Careful with the block multiplication here!

Let's do the second term more explicitly:

X \otimes ∣1 ⟩ ⟨ 1∣ = (0110) \otimes (0001) = 0 \cdot (0001) 1 \cdot (0001) 1 \cdot (0001) 0 \cdot (0001) = 0000000100000100

Summing the two parts:

CNOT_{rev} = 1000000100100100

This matrix swaps the states $∣01 ⟩$ and $∣11 ⟩$ , which is exactly what we expect: the state of the first qubit is flipped only when the second qubit is 1.

3. Operators That Create Entanglement

An important insight is that the CNOT gate cannot be written as a simple tensor product of two single-qubit gates, $A \otimes B$ . It is an inherently two-qubit operation. This is precisely why it can create entanglement.

Consider the separable input state $∣ ψ ⟩ = \frac{1}{2} (∣0 ⟩ + ∣1 ⟩) \otimes ∣0 ⟩$ . In vector form, this is $\frac{1}{2} (∣00 ⟩ + ∣10 ⟩)$ .
Let's apply CNOT:

CNOT ∣ ψ ⟩ = \frac{1}{2} (CNOT ∣00 ⟩ + CNOT ∣10 ⟩)

Since $CNOT ∣00 ⟩ = ∣00 ⟩$ and $CNOT ∣10 ⟩ = ∣11 ⟩$ , the result is:

∣ ψ_{out} ⟩ = \frac{1}{2} (∣00 ⟩ + ∣11 ⟩)

This is the famous Bell state, which we know from a previous lesson is entangled. An operator that can be factored as $A \otimes B$ cannot create entanglement from a separable state, but operators like CNOT can.

Conclusion

In this lesson, you have learned how to represent operations on multi-qubit systems. This is a fundamental skill for both quantum computing and the broader study of quantum mechanics.

Key Takeaways:

An operator acting separately on two subsystems is represented by the tensor product (Kronecker product) of their individual operator matrices.
The key property is $(A \otimes B) (v \otimes w) = (A v) \otimes (B w)$ .
The CNOT gate is a fundamental two-qubit operator that flips a target qubit conditional on the state of a control qubit.
The CNOT gate can be represented elegantly as a sum of tensor products: $CNOT = ∣0 ⟩ ⟨ 0∣ \otimes I + ∣1 ⟩ ⟨ 1∣ \otimes X$ .
Operators like CNOT, which cannot be factored into a simple tensor product $A \otimes B$ , are essential for creating entanglement.

Preview of the Next Lesson:

We have now covered the full basics of tensor products for quantum systems: defining spaces, representing states, and representing operators. You are now equipped to tackle topics in both quantum computing and deep learning. We will now move on to a new module focused on Matrix Calculus and Optimization, starting with how to compute gradients of functions with respect to vectors and matrices—a critical skill for training machine learning models.

Recommended resources

1. The Tensor Product of Operators

2. The Controlled-NOT (CNOT) Gate

CNOT as a Sum of Tensor Products

3. Operators That Create Entanglement

Conclusion