Quantum Simulation

Why Quantum Simulation?

Simulating quantum systems is exponentially hard on classical computers. Feynman's insight (1982) was that a quantum computer could efficiently simulate quantum mechanics:

For an -particle system, the Hilbert space has dimension . A quantum computer with qubits can represent this space directly.

Hamiltonian Simulation

Given a Hamiltonian where each is a local term, we want to compute:

For small , we can use the Trotter-Suzuki decomposition:

where is the number of Trotter steps. The error decreases as for first-order Trotter and for second-order Trotter.

Product Formulas

First-order Trotter:

Second-order Trotter (symmetric):

Higher-order formulas achieve error with th-order symmetric Trotter.

The total gate count for Trotter simulation is where is the number of terms.

Quantum Phase Estimation for Simulation

An alternative to Trotter is quantum phase estimation (QPE). If we can implement , QPE extracts eigenvalues of :

QPE outputs a binary approximation to with precision using ancilla qubits.

Resources: QPE requires deep circuits and is only feasible with error correction. For near-term simulation, variational approaches are more practical.

Quantum Chemistry

The most promising application of quantum simulation is computational chemistry. The electronic structure Hamiltonian in second quantization:

maps to qubit operators via Jordan-Wigner or Bravyi-Kitaev transformations.

Key metrics: chemical accuracy (~1 kcal/mol) requires ~10^{-3} Hartree precision, achievable with fault-tolerant quantum computers using gates for basis functions.

Classical Simulation Limits

Classical simulation of quantum circuits is limited by exponential state vector growth. However, many quantum algorithms have limited entanglement that can be exploited:

• Matrix Product States (MPS): efficiently represent low-entanglement states
• Tensor networks: generalize MPS to higher dimensions
• Stabilizer simulation: efficient for Clifford circuits (Gottesman-Knill theorem)

For random circuits with qubits and depth , classical simulation requires time and memory.

Python: Hamiltonian Simulation

import numpy as np
import scipy.linalg

def hamiltonian_simulation():
    # Simulate a simple 2-qubit Hamiltonian.
    Z = np.array([[1,0],[0,-1]], dtype=complex)
    X = np.array([[0,1],[1,0]], dtype=complex)
    I = np.eye(2, dtype=complex)

    H = 0.5 * np.kron(Z, I) + 0.5 * np.kron(I, Z) + 0.3 * np.kron(X, X)

    eigenvalues, eigenvectors = np.linalg.eigh(H)
    print("Eigenvalues:", eigenvalues)
    print("Ground state energy:", eigenvalues[0])

    t = 0.5
    U = scipy.linalg.expm(-1j * H * t)
    psi0 = np.array([1,0,0,0], dtype=complex)
    psi_t = U @ psi0

    print(f"State at t={t}: {np.round(psi_t, 4)}")
    print(f"Probabilities: {np.round(np.abs(psi_t)**2, 4)}")

hamiltonian_simulation()

This demonstrates exact diagonalization and time evolution for a simple quantum system.

Hamiltonian Simulation Methods

Product Formula Error Bounds

For the th-order Trotter formula:

The error decreases as with Trotter steps. The total gate count is where is the number of Hamiltonian terms.

For optimal precision per gate, choose .