Multi-Qubit Systems

Multi-Qubit Systems#

Tensor products, CNOT, entangling gates, and the exponential growth of Hilbert space. Bell state preparation circuits.

Single-qubit gates alone cannot produce entanglement or provide a quantum computational advantage. Multi-qubit gates, combined with single-qubit rotations, complete the universal gate set and unlock the full power of quantum computing.

Tensor Products#

The state space of \(n\) qubits is the tensor product of individual qubit spaces:

\[\mathcal{H} = \underbrace{\mathbb{C}^2 \otimes \mathbb{C}^2 \otimes \cdots \otimes \mathbb{C}^2}_{n} = \mathbb{C}^{2^n}\]

For two qubits in states \(|\psi\rangle = \alpha|0\rangle + \beta|1\rangle\) and \(|\phi\rangle = \gamma|0\rangle + \delta|1\rangle\):

\[|\psi\rangle \otimes |\phi\rangle = \alpha\gamma|00\rangle + \alpha\delta|01\rangle + \beta\gamma|10\rangle + \beta\delta|11\rangle\]

Exponential Growth#

Qubits (\(n\))

Dimension (\(2^n\))

Complex amplitudes

1

2

2

2

4

4

10

1,024

1,024

20

\(\sim 10^6\)

\(\sim 10^6\)

50

\(\sim 10^{15}\)

\(\sim 10^{15}\)

300

\(\sim 10^{90}\)

More than atoms in the universe

This exponential scaling is why classical simulation of quantum computers is intractable for large \(n\), and why quantum computers are potentially powerful.

The CNOT Gate#

The controlled-NOT (CNOT) gate is the standard two-qubit entangling gate. It flips the target qubit if and only if the control qubit is \(|1\rangle\):

\[\begin{split}\text{CNOT} = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix}\end{split}\]

Action on computational basis states:

\[|00\rangle \mapsto |00\rangle, \quad |01\rangle \mapsto |01\rangle, \quad |10\rangle \mapsto |11\rangle, \quad |11\rangle \mapsto |10\rangle\]

In compact notation: \(\text{CNOT}|a, b\rangle = |a, a \oplus b\rangle\) where \(\oplus\) is addition modulo 2.

CNOT Creates Entanglement

The CNOT gate is not entangling by itself on computational basis states (it maps product states to product states). It creates entanglement when the control qubit is in a superposition. For example: \(\text{CNOT}(|+\rangle|0\rangle) = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle) = |\Phi^+\rangle\). This is a Bell state and maximally entangled.

Bell State Preparation#

The four Bell states are prepared by applying Hadamard + CNOT to different input states:

Input

Circuit

Output Bell State

\(|00\rangle\)

\(H \otimes I\) then CNOT

\(|\Phi^+\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle)\)

\(|10\rangle\)

\(H \otimes I\) then CNOT

\(|\Phi^-\rangle = \frac{1}{\sqrt{2}}(|00\rangle - |11\rangle)\)

\(|01\rangle\)

\(H \otimes I\) then CNOT

\(|\Psi^+\rangle = \frac{1}{\sqrt{2}}(|01\rangle + |10\rangle)\)

\(|11\rangle\)

\(H \otimes I\) then CNOT

\(|\Psi^-\rangle = \frac{1}{\sqrt{2}}(|01\rangle - |10\rangle)\)

Step by step for \(|00\rangle \to |\Phi^+\rangle\):

\[|00\rangle \xrightarrow{H \otimes I} \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)|0\rangle = \frac{1}{\sqrt{2}}(|00\rangle + |10\rangle)\]
\[\xrightarrow{\text{CNOT}} \frac{1}{\sqrt{2}}(|00\rangle + |11\rangle) = |\Phi^+\rangle\]

Other Two-Qubit Gates#

CZ (Controlled-Z)#

Applies a \(Z\) gate to the target when the control is \(|1\rangle\):

\[\begin{split}\text{CZ} = \begin{pmatrix} 1&0&0&0 \\ 0&1&0&0 \\ 0&0&1&0 \\ 0&0&0&-1 \end{pmatrix}\end{split}\]

CZ is symmetric: it does not matter which qubit is control and which is target. It is the native entangling gate on many superconducting platforms.

SWAP#

Exchanges the states of two qubits:

\[\text{SWAP}|a,b\rangle = |b,a\rangle\]

SWAP can be decomposed into three CNOTs: \(\text{SWAP} = \text{CNOT}_{12} \cdot \text{CNOT}_{21} \cdot \text{CNOT}_{12}\).

iSWAP#

\[\begin{split}\text{iSWAP} = \begin{pmatrix} 1&0&0&0 \\ 0&0&i&0 \\ 0&i&0&0 \\ 0&0&0&1 \end{pmatrix}\end{split}\]

Native to some superconducting architectures (Google Sycamore). Swaps and adds a phase.

Universality#

Universal Gate Set

Any single-qubit gate set that is universal for SU(2), combined with any entangling two-qubit gate (CNOT, CZ, iSWAP, etc.), forms a universal gate set for quantum computation. This means any \(n\)-qubit unitary can be decomposed into a sequence of single-qubit and two-qubit gates from this set.

The standard universal gate set is \(\{H, T, \text{CNOT}\}\):

  • \(H\) and \(T\) generate all single-qubit unitaries (approximately)

  • CNOT provides entanglement

  • Together, they can approximate any unitary on \(n\) qubits

Multi-Qubit Operators#

Operators on composite systems are built from tensor products:

\[\begin{split}X \otimes Z = \begin{pmatrix} 0&0&1&0 \\ 0&0&0&-1 \\ 1&0&0&0 \\ 0&-1&0&0 \end{pmatrix}\end{split}\]

This applies \(X\) to the first qubit and \(Z\) to the second qubit simultaneously. Independent single-qubit operations are always tensor products; entangling operations are not.

Controlled Operations#

Any single-qubit gate \(U\) can be made into a controlled gate:

\[C\text{-}U = |0\rangle\langle 0| \otimes I + |1\rangle\langle 1| \otimes U\]

This applies \(U\) to the target qubit only when the control qubit is \(|1\rangle\). Controlled gates are the primary mechanism for creating conditional quantum logic.

Code Examples#

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

# Create Bell state |Phi+>
qc = QuantumCircuit(2)
qc.h(0)       # Hadamard on qubit 0
qc.cx(0, 1)   # CNOT with control=0, target=1

sv = Statevector.from_instruction(qc)
print("Bell state:", sv)
# Output: [0.707+0j, 0, 0, 0.707+0j]

# Create GHZ state |000> + |111> for 3 qubits
ghz = QuantumCircuit(3)
ghz.h(0)
ghz.cx(0, 1)
ghz.cx(0, 2)

sv_ghz = Statevector.from_instruction(ghz)
print("GHZ state:", sv_ghz)

import cirq

q0, q1 = cirq.LineQubit.range(2)

# Bell state circuit
bell_circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
])
print(bell_circuit)

# Simulate
sim = cirq.Simulator()
result = sim.simulate(bell_circuit)
print("Bell state:", result.final_state_vector)

# GHZ state
q0, q1, q2 = cirq.LineQubit.range(3)
ghz_circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.CNOT(q0, q2),
])
result_ghz = sim.simulate(ghz_circuit)
print("GHZ state:", result_ghz.final_state_vector)

import pennylane as qml
import numpy as np

dev = qml.device("default.qubit", wires=2)

@qml.qnode(dev)
def bell_state():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    return qml.state()

state = bell_state()
print("Bell state:", state)
# Output: [0.707, 0, 0, 0.707]

# GHZ state
dev3 = qml.device("default.qubit", wires=3)

@qml.qnode(dev3)
def ghz_state():
    qml.Hadamard(wires=0)
    qml.CNOT(wires=[0, 1])
    qml.CNOT(wires=[0, 2])
    return qml.state()

print("GHZ state:", ghz_state())

from pyquil import Program
from pyquil.gates import H, CNOT, MEASURE
from pyquil.quilbase import DefGate

# Bell state
bell = Program()
bell += H(0)
bell += CNOT(0, 1)
print("Bell circuit:")
print(bell)

# GHZ state
ghz = Program()
ghz += H(0)
ghz += CNOT(0, 1)
ghz += CNOT(0, 2)
print("GHZ circuit:")
print(ghz)

The GHZ State#

The Greenberger-Horne-Zeilinger (GHZ) state generalizes the Bell state to \(n\) qubits:

\[|\text{GHZ}\rangle = \frac{1}{\sqrt{2}}(|00\cdots0\rangle + |11\cdots1\rangle)\]

It is prepared by applying \(H\) to the first qubit, then CNOT from the first qubit to every other qubit. The GHZ state exhibits maximal \(n\)-partite entanglement and violates multi-party Bell inequalities.

Further Reading#

  • Nielsen, M. A. & Chuang, I. L. (2010). Quantum Computation and Quantum Information, Sections 4.3-4.5.

  • Barenco, A. et al. (1995). “Elementary gates for quantum computation.” Physical Review A, 52(5), 3457-3467.

  • Greenberger, D. M., Horne, M. A., & Zeilinger, A. (1989). “Going beyond Bell’s Theorem.” In Bell’s Theorem, Quantum Theory, and Conceptions of the Universe, pp. 69-72. Springer.