Hybrid Quantum-Classical Algorithms

Hybrid Quantum-Classical Algorithms#

VQE, QAOA, quantum neural networks, and the variational principle. Classical optimizers (COBYLA, SPSA, Adam) for quantum parameters.

Hybrid quantum-classical algorithms partition computation between a quantum processor (which evaluates short circuits) and a classical processor (which optimizes circuit parameters). This division is not a compromise; it is a design principle that matches the strengths of each processor type. The quantum circuit explores a Hilbert space that is exponentially large, while the classical optimizer navigates a parameter landscape that is polynomially sized.

The Hybrid Loop#

The general structure of a hybrid algorithm:

A classical optimizer proposes parameters \(\boldsymbol{\theta}\).
A parameterized quantum circuit \(U(\boldsymbol{\theta})\) is executed on quantum hardware.
Measurements yield an estimate of the cost function \(C(\boldsymbol{\theta})\).
The optimizer updates \(\boldsymbol{\theta}\) based on \(C\) (and optionally its gradient).
Repeat until convergence.

The cost function is typically an expectation value:

\[C(\boldsymbol{\theta}) = \langle 0|U^\dagger(\boldsymbol{\theta})\, H\, U(\boldsymbol{\theta})|0\rangle\]

where \(H\) is a problem-specific Hamiltonian or observable.

Variational Quantum Eigensolver (VQE)#

VQE finds the ground state energy of a Hamiltonian \(H\) using the variational principle:

\[E_0 \leq \langle\psi(\boldsymbol{\theta})|H|\psi(\boldsymbol{\theta})\rangle \quad \text{for all } \boldsymbol{\theta}\]

The minimum over all parameters gives an upper bound on the ground state energy. VQE is the most studied hybrid algorithm and the primary approach for quantum chemistry on near-term devices.

VQE for Molecular Hamiltonians#

A molecular Hamiltonian in second quantization is mapped to qubit operators via Jordan-Wigner or Bravyi-Kitaev transformations. The result is a sum of Pauli strings:

\[H = \sum_i c_i P_i, \quad P_i \in \{I, X, Y, Z\}^{\otimes n}\]

Each term \(\langle P_i \rangle\) is measured independently, and the results are classically summed with coefficients \(c_i\).

Measurement overhead

A molecular Hamiltonian on \(n\) qubits may have \(O(n^4)\) Pauli terms. Each term requires separate measurements (or grouping into commuting sets). This measurement overhead often dominates the total runtime of VQE.

QAOA#

The Quantum Approximate Optimization Algorithm applies the hybrid framework to combinatorial optimization. The circuit structure is fixed by the problem Hamiltonian (see Adiabatic Quantum Computing), and the classical optimizer tunes the \(2p\) parameters \((\boldsymbol{\gamma}, \boldsymbol{\beta})\).

QAOA differs from generic VQE in that the ansatz is problem-inspired: the cost and mixer layers directly implement the problem structure, rather than using a hardware-efficient template.

Quantum Neural Networks#

Quantum neural networks (QNNs) use the hybrid framework for supervised learning tasks. The circuit takes classical data as input (via data encoding) and outputs predictions via measurement.

A QNN with \(L\) layers computes:

\[f(\mathbf{x}; \boldsymbol{\theta}) = \langle 0|U^\dagger(\mathbf{x}, \boldsymbol{\theta})\, O\, U(\mathbf{x}, \boldsymbol{\theta})|0\rangle\]

where \(O\) is a measurement observable. Training minimizes a loss function:

\[\mathcal{L}(\boldsymbol{\theta}) = \frac{1}{N}\sum_{i=1}^{N} \ell(f(\mathbf{x}_i; \boldsymbol{\theta}), y_i)\]

with \(\ell\) being a task-specific loss (mean squared error for regression, cross-entropy for classification).

Classical Optimizers#

The choice of classical optimizer is critical. Quantum cost landscapes are noisy (due to shot noise and hardware noise) and potentially non-convex.

Optimizer	Gradient-Free	Noise Robust	Notes
COBYLA	Yes	Moderate	Constrained optimization, good for few parameters
Nelder-Mead	Yes	Low	Simplex method, struggles in high dimensions
SPSA	No (approximates)	High	Stochastic perturbation, only 2 cost evaluations per step
Adam	No	Moderate	Momentum-based, requires gradient estimates
L-BFGS-B	No	Low	Quasi-Newton, fast convergence but noise-sensitive
NFT (Natural Gradient)	No	Moderate	Uses quantum Fisher information, better convergence

The Parameter Shift Rule#

Gradients of quantum circuits can be computed exactly (up to shot noise) using the parameter shift rule. For a gate \(R(\theta) = e^{-i\theta G/2}\) where \(G\) has eigenvalues \(\pm 1\):

\[\frac{\partial C}{\partial \theta} = \frac{C(\theta + \pi/2) - C(\theta - \pi/2)}{2}\]

This requires two circuit evaluations per parameter, making gradient computation scale linearly with the number of parameters.

Tip

SPSA (Simultaneous Perturbation Stochastic Approximation) requires only 2 circuit evaluations per optimization step regardless of the number of parameters, making it attractive for circuits with many parameters on noisy hardware.

Code Examples#

Qiskit

from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.primitives import StatevectorEstimator
from qiskit.quantum_info import SparsePauliOp
from scipy.optimize import minimize
import numpy as np

# Simple VQE: find ground state of H = Z0 Z1 + 0.5 X0
H = SparsePauliOp.from_list([("ZZ", 1.0), ("XI", 0.5)])

n_qubits = 2
theta = [Parameter(f'θ_{i}') for i in range(4)]

qc = QuantumCircuit(n_qubits)
qc.ry(theta[0], 0)
qc.ry(theta[1], 1)
qc.cx(0, 1)
qc.ry(theta[2], 0)
qc.ry(theta[3], 1)

estimator = StatevectorEstimator()

def cost(params):
    bound = qc.assign_parameters(dict(zip(theta, params)))
    job = estimator.run([(bound, H)])
    return job.result()[0].data.evs

result = minimize(cost, np.random.randn(4), method='COBYLA')
print(f"Ground state energy: {result.fun:.4f}")

Cirq

import cirq
import numpy as np
from scipy.optimize import minimize

qubits = cirq.LineQubit.range(2)

def build_circuit(params):
    circuit = cirq.Circuit([
        cirq.ry(params[0]).on(qubits[0]),
        cirq.ry(params[1]).on(qubits[1]),
        cirq.CNOT(qubits[0], qubits[1]),
        cirq.ry(params[2]).on(qubits[0]),
        cirq.ry(params[3]).on(qubits[1]),
    ])
    return circuit

def cost(params):
    circuit = build_circuit(params)
    sim = cirq.Simulator()
    result = sim.simulate(circuit)
    state = result.final_state_vector
    # H = Z0 Z1 + 0.5 X0
    ZZ = np.diag([1, -1, -1, 1])
    XI = np.kron(np.array([[0,1],[1,0]]), np.eye(2))
    H = ZZ + 0.5 * XI
    return np.real(state.conj() @ H @ state)

result = minimize(cost, np.random.randn(4), method='COBYLA')
print(f"Ground state energy: {result.fun:.4f}")

PennyLane

import pennylane as qml
from pennylane import numpy as np

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

@qml.qnode(dev)
def cost_fn(params):
    qml.RY(params[0], wires=0)
    qml.RY(params[1], wires=1)
    qml.CNOT(wires=[0, 1])
    qml.RY(params[2], wires=0)
    qml.RY(params[3], wires=1)
    # H = Z0 Z1 + 0.5 X0
    return qml.expval(
        qml.PauliZ(0) @ qml.PauliZ(1) + 0.5 * qml.PauliX(0)
    )

opt = qml.AdamOptimizer(stepsize=0.1)
params = np.random.randn(4, requires_grad=True)

for step in range(100):
    params = opt.step(cost_fn, params)

print(f"Ground state energy: {cost_fn(params):.4f}")

PyQuil

from pyquil import Program
from pyquil.gates import RY, CNOT
from pyquil.api import WavefunctionSimulator
import numpy as np
from scipy.optimize import minimize

sim = WavefunctionSimulator()

def cost(params):
    prog = Program()
    prog += RY(params[0], 0)
    prog += RY(params[1], 1)
    prog += CNOT(0, 1)
    prog += RY(params[2], 0)
    prog += RY(params[3], 1)
    wf = sim.wavefunction(prog).amplitudes
    # H = Z0 Z1 + 0.5 X0
    ZZ = np.diag([1, -1, -1, 1])
    XI = np.kron(np.array([[0,1],[1,0]]), np.eye(2))
    H = ZZ + 0.5 * XI
    return np.real(wf.conj() @ H @ wf)

result = minimize(cost, np.random.randn(4), method='COBYLA')
print(f"Ground state energy: {result.fun:.4f}")