variational intermediate · 16 min read · April 29, 2026

The Parameter-Shift Rule: Computing Exact Quantum Gradients on Real Hardware

The parameter-shift rule is the standard exact-gradient method for variational quantum algorithms. Unlike finite differences, the rule produces unbiased gradient estimates with no truncation error, on real hardware, using only two extra circuit evaluations per parameter. This tutorial derives the rule from first principles, covers the generalized and stochastic variants for non-Pauli generators, and gives a decision rule for when parameter shift is the right gradient method.

Prerequisites: Tutorial 13: Variational Quantum Eigensolver, Tutorial 38: ADAPT-VQE

Tutorial 13’s VQE and tutorial 38’s ADAPT-VQE both rely on a single pivotal piece of machinery: a way to compute the gradient of an expectation value with respect to a circuit parameter. Without exact gradients, variational algorithms degrade to derivative-free optimization, which is much slower in high dimensions.

The standard answer is the parameter-shift rule (Mitarai, Negoro, Kitagawa, Fujii 2018; Schuld, Bergholm, Gogolin, Izaac, Killoran 2019). The rule has a remarkable property: for the standard case of a parameterized rotation gate $e^{-i \theta \sigma / 2}$ with $\sigma$ a Pauli operator, the exact gradient is the difference of two expectations evaluated at parameter values shifted by $\pm \pi/2$. No truncation error, no finite-difference Taylor-series cutoff — the formula is exact, and it requires only two extra circuit evaluations per parameter.

This is the kind of result that sounds too good to be true. It is exact only because of the specific structure of Pauli rotations; for generators with multiple eigenvalues the rule generalizes to a more complex formula (Wierichs et al. 2022). For non-Pauli-rotation gates (e.g., the MultiRZ or hardware-specific entangling gates), specialized variants exist.

This tutorial derives the parameter-shift rule from first principles, covers the generalizations, and gives a decision rule for when to use parameter-shift versus finite differences versus alternative methods.

The setup

Consider a parameterized circuit composed of fixed unitaries and parameterized gates. Focus on a single parameterized gate $G(\theta) = e^{-i \theta H_G / 2}$ embedded inside the circuit, where $H_G$ is the Hermitian generator of the rotation. Define the expectation as a function of the parameter:

$$f(\theta) \;=\; \langle \psi_0 | U_1^\dagger \, G^\dagger(\theta) \, U_2^\dagger \, M \, U_2 \, G(\theta) \, U_1 | \psi_0 \rangle,$$

where $U_1, U_2$ are the rest of the circuit (independent of $\theta$) and $M$ is the observable being measured.

The goal is to compute $\partial f / \partial \theta$ exactly.

The two-eigenvalue case: the standard parameter-shift rule

Suppose $H_G$ has only two distinct eigenvalues, $\pm 1$ (which is the case for any Pauli operator: $H_G = \sigma$ with $\sigma \in \{X, Y, Z\}$). Then $G(\theta) = \cos(\theta/2) I - i \sin(\theta/2) \sigma$, a clean form to differentiate.

The result, after a few lines of algebra (worked through cleanly in Schuld 2019), is:

$$\frac{\partial f}{\partial \theta} \;=\; \frac{1}{2}\Bigl[ f\bigl(\theta + \tfrac{\pi}{2}\bigr) - f\bigl(\theta - \tfrac{\pi}{2}\bigr) \Bigr].$$

The gradient is exactly the difference of the function evaluated at two shifted parameter values, divided by 2. No approximation. No higher-order terms. The formula is exact for any Pauli-rotation gate.

The proof uses the fact that for two-eigenvalue $H_G$, $f(\theta)$ is a finite trigonometric polynomial in $\theta$ — specifically, $f(\theta) = a + b \cos\theta + c \sin\theta$ for some constants $a, b, c$. A function of this form is uniquely determined by its values at two appropriately chosen shifted points, and the difference formula captures the derivative exactly.

This derivation matters because it shows the formula is not a Taylor approximation. It is an algebraic identity exploiting the trigonometric structure of two-eigenvalue Pauli rotations.

The shot-noise budget

Quantum hardware does not return $f(\theta)$ exactly; it returns a sample average over a finite number of measurement shots. With $N_\text{shots}$ shots, the standard error of the expectation $f(\theta)$ is approximately $\sigma_M / \sqrt{N_\text{shots}}$, where $\sigma_M$ is the spread of the observable’s eigenvalues.

The parameter-shift gradient is a difference of two such samples:

$$\widehat{\partial_\theta f} \;=\; \frac{1}{2}\bigl[\hat{f}(\theta + \pi/2) - \hat{f}(\theta - \pi/2)\bigr],$$

with variance:

$$\mathrm{Var}\bigl[\widehat{\partial_\theta f}\bigr] \;=\; \frac{\sigma_M^2}{2 N_\text{shots}}.$$

So the standard error of the gradient is comparable to the standard error of the function value, just from twice the shots. This is much better than the noise scaling of finite differences — a finite difference with step $h$ amplifies shot noise by $1/h$, with $h$ typically $\sim 10^{-3}$ for accuracy.

Parameter-shift is shot-efficient. This is the dominant practical reason to use it on real hardware.

The generalized parameter-shift rule

When $H_G$ has more than two distinct eigenvalues — which happens for many practical gates like multi-qubit rotations $e^{-i \theta (X \otimes X)}$ or hardware-specific gates with multi-eigenvalue generators — the standard formula doesn’t apply. The generalized rule (Wierichs, Izaac, Wang, Lin 2022) handles this.

The general principle: if $H_G$ has $K$ distinct eigenvalues, $f(\theta)$ is a sum of at most $2K - 1$ Fourier components in $\theta$. To recover such a function and its derivative, you need at least $2K - 1$ shifted samples.

For $K = 2$ (Pauli rotations), this gives the standard 2-shift rule. For $K = 3$ (e.g., 3-eigenvalue generators), you need 4 shifts. The shifts are chosen to make the resulting linear system well-conditioned; Wierichs 2022 gives optimal shift choices for each $K$.

In practice, most variational algorithms use Pauli-rotation gates exclusively, and the standard 2-shift rule covers everything. For algorithms using non-Pauli generators (some hardware-native gates, fSim gates, fermionic excitations directly compiled), the generalized rule is necessary.

Stochastic parameter-shift rule

For gates with continuous-eigenvalue generators (e.g., parametrized Hamiltonian-evolution gates $e^{-i \theta H}$ where $H$ has a continuous spectrum), no finite-shift rule is exact. Stochastic parameter-shift rules (Banchi-Crooks 2021) handle this: instead of fixed shifts, sample shifts from a distribution and average.

The result is unbiased (the expected estimator equals the true gradient) but with higher variance than the deterministic 2-shift rule for Pauli gates. Used primarily in quantum simulation and chemistry algorithms with Hamiltonian-evolution ansätze.

Comparison: parameter-shift vs alternatives

Method	Bias	Shot-efficiency	Hardware support	Use when
Parameter-shift (2-term)	exact	excellent	universal for Pauli rotations	default for most VQAs
Finite difference	$O(h^2)$ truncation	poor (1/$h$ amplification)	universal	classical simulators, debugging
Generalized parameter-shift	exact	good	requires careful shift choice	non-Pauli generators
Stochastic parameter-shift	unbiased	moderate	continuous-eigenvalue generators	rare; specialized algorithms
SPSA	unbiased	good in 1D, poor in high-D	universal	very large parameter counts where 2 shifts × $N_\text{params}$ is too expensive
Adjoint differentiation	exact	best	classical simulators only	classical preprocessing of VQAs

The dominant choice in 2026: parameter-shift on real hardware, adjoint differentiation in simulators. Use SPSA only when the parameter count is so large that even $2 \times N_\text{params}$ circuit evaluations per gradient step is too expensive.

A working PennyLane example

Concrete code showing parameter-shift in action:

import numpy as np
import pennylane as qml
from pennylane import numpy as pnp

n_qubits = 3
dev = qml.device("default.qubit", wires=n_qubits, shots=1000)

@qml.qnode(dev, diff_method="parameter-shift")
def circuit(params):
    for q in range(n_qubits):
        qml.RY(params[q], wires=q)
    qml.CNOT(wires=[0, 1])
    qml.CNOT(wires=[1, 2])
    return qml.expval(qml.PauliZ(0) @ qml.PauliZ(2))


# Compute the gradient at a random point.
params = pnp.array([0.5, 0.7, 1.1], requires_grad=True)

# Parameter-shift gradient (exact in expectation, shot-noise-limited).
grad_ps = qml.grad(circuit)(params)
print("Parameter-shift gradient:", grad_ps)

# Finite-difference gradient for comparison.
def finite_diff(f, x, h=1e-3):
    grads = np.zeros_like(x)
    for i in range(len(x)):
        x_plus = x.copy(); x_plus[i] += h
        x_minus = x.copy(); x_minus[i] -= h
        grads[i] = (f(x_plus) - f(x_minus)) / (2 * h)
    return grads

grad_fd = finite_diff(lambda x: circuit(x), np.array(params))
print("Finite-difference gradient:", grad_fd)

# At 1000 shots both should agree to ~3 digits at the actual expectation.
# At lower shots, parameter-shift remains unbiased but finite-difference
# amplifies shot noise by 1/h ~ 1000.

The two methods agree at moderate shot counts. At lower shot counts, finite differences become unreliable while parameter-shift stays unbiased.

PennyLane’s diff_method="parameter-shift" automatically applies the rule — including the generalized version when needed — so production VQE/QAOA code rarely needs to implement parameter-shift manually.

Why parameter-shift matters for ADAPT-VQE

ADAPT-VQE’s per-iteration screening step is essentially a parameter-shift gradient computation: for each candidate operator, compute the energy gradient at the current state with the candidate operator inserted at $\theta = 0$. Each gradient costs 2 circuit evaluations.

If parameter-shift didn’t exist, ADAPT screening would have to use finite differences (more shots needed) or exhaustive optimization of each candidate (much more expensive). The parameter-shift rule is what makes adaptive algorithms practically feasible on real hardware.

This connects back to the barren-plateau picture in tutorial 37: training requires gradients, gradients are expensive on quantum hardware, and parameter-shift is the cheapest reliable way to get them. In a barren-plateau regime where gradients are tiny, the shot-noise budget for parameter-shift becomes prohibitive — needing $1/\sigma_g^2 \sim 2^n$ shots per gradient evaluation. The parameter-shift rule is exact, but exactness doesn’t help when the gradient itself is statistically unmeasurable.

Common misconceptions

“Parameter-shift is exact, so shot noise doesn’t matter.” Wrong. Parameter-shift is unbiased — its expected value is the true gradient. But each individual measurement has shot noise; you need enough shots to average out the noise. In barren-plateau regimes where gradients are small, the shot count needed scales exponentially.

“Parameter-shift requires a $\pm \pi/2$ shift specifically.” Only for Pauli rotations. Other generators require different shift values; the generalized rule (Wierichs 2022) gives the optimal choices.

“Parameter-shift doesn’t work for ZZ rotations.” It does, with appropriate shift choices. $e^{-i \theta Z \otimes Z}$ has a 2-eigenvalue generator (since $(Z \otimes Z)^2 = I$), so the standard rule applies. Multi-qubit Pauli rotations are still 2-eigenvalue.

“Finite differences are simpler and just as good.” They are simpler but much worse on shot noise. For the same shot budget, parameter-shift gradients have 100-1000× lower variance than finite-difference gradients. The simplicity is a false economy.

“Adjoint differentiation is always better than parameter-shift.” Only on classical simulators. On real quantum hardware, you cannot “back-propagate through a quantum circuit” — quantum measurements destroy the state. Parameter-shift is the only way to get exact gradients on real hardware; adjoint differentiation works only in simulation.

Decision rule

For each parameterized gate in your variational circuit:

1. Is the generator a Pauli operator (or tensor product of Paulis)? Use the standard 2-shift rule. This is the default for almost all VQE/QAOA/QML code.
2. Is the generator a non-Pauli with $K$ distinct eigenvalues? Use the generalized $(2K-1)$-shift rule. PennyLane handles this automatically.
3. Is the generator continuous-spectrum? Use stochastic parameter-shift. This is rare; usually you’ll Trotterize the evolution into smaller Pauli-generator gates instead.
4. Are you training on a classical simulator? Switch to diff_method="adjoint" in PennyLane for $10$-$100\times$ speedup. Adjoint differentiation is exact and much faster than parameter-shift in simulation.
5. Is your parameter count enormous (e.g., 10,000+)? Consider SPSA: instead of $2N$ circuit evaluations per gradient step, SPSA uses $2$ evaluations per step at the cost of higher variance per step. Net wins on parameter counts where parameter-shift would be too expensive.

The vast majority of 2026 variational quantum work uses standard parameter-shift on real hardware and adjoint differentiation in simulation. Other methods are specialized choices for specific situations.

Exercises

1. Why $\pm \pi/2$ specifically

Show that for $H_G = \sigma$ a Pauli operator (with eigenvalues $\pm 1$), the parameter-shift formula with shift $\pm s$ gives the exact gradient when $s = \pi/2$. What goes wrong with $s = \pi/4$?

Show answer

For Pauli generator: $f(\theta) = a + b \cos\theta + c \sin\theta$. Then $f'(\theta) = -b \sin\theta + c \cos\theta$. The parameter-shift formula: $f(\theta + s) - f(\theta - s) = 2b \cos\theta \cdot 0 + 2c \sin s \cos\theta + 2(-b \sin s \sin\theta) = -2b \sin s \sin\theta + 2c \sin s \cos\theta = 2 \sin s \cdot f'(\theta)$. Dividing by $2 \sin s$ gives $f'(\theta)$ exactly. For $s = \pi/2$, $\sin s = 1$, so the prefactor is $1/2$ — the standard parameter-shift formula. For $s = \pi/4$, $\sin s = 1/\sqrt{2}$, so the prefactor is $1/\sqrt{2}$ instead. Both are valid, but $s = \pi/2$ is optimal: it minimizes the variance amplification of the noisy estimator (since $\sin s$ is largest at $s = \pi/2$).

2. Shot budget for ADAPT screening

A chemistry pool has 200 candidate operators. Each parameter-shift gradient takes 2 circuit evaluations at 1,000 shots each. To screen all 200 operators per ADAPT iteration with usable accuracy, what is the total shot budget per iteration?

Show answer

Per operator: 2 circuit evaluations × 1,000 shots = 2,000 shots. Total per screening: $200 \times 2{,}000 = 400{,}000$ shots. At a typical 2026 hardware shot rate of $\sim 1$ kHz, that’s ~7 minutes per screening pass. Plus the optimization step (which uses parameter-shift gradients on the chosen ansatz too). For a 20-iteration ADAPT run, total wall-clock is hours, with screening dominating early iterations and optimization dominating late iterations.

3. When adjoint beats parameter-shift

You are training a variational quantum algorithm with 100 parameters on a classical simulator. Compare the cost of computing the gradient via parameter-shift vs adjoint differentiation.

Show answer

Parameter-shift: $2 \times 100 = 200$ circuit evaluations. Adjoint differentiation: $\sim 1$ forward pass + $1$ backward pass of $O(N \cdot G)$ work, where $N$ is the qubit count and $G$ is the gate count. Adjoint is $\sim 100\times$ faster for this size, and the speedup grows with parameter count. This is why production training pipelines for VQE/QAOA/QML in 2026 use adjoint exclusively for simulation-based training, switching to parameter-shift only when running on real hardware. The same algorithm code can use both — the differentiation method is an interface choice, not an algorithm choice.

4. Why SPSA scales better in high dimensions

For an algorithm with $N$ parameters and parameter-shift gradient estimation, the per-step cost is $O(N)$ circuit evaluations. SPSA uses constant 2 evaluations regardless of $N$. Why is parameter-shift still preferred for $N \sim 100$?

Show answer

SPSA’s per-step variance is much higher than parameter-shift’s because it estimates the projection of the gradient onto a random direction, not the full gradient. To converge to the optimum, SPSA needs $O(1)$ steps × $O(N)$ epochs (instead of parameter-shift’s $O(1)$ steps × $O(1)$ evaluations of the full gradient per step). The total cost is comparable for moderate $N$, but parameter-shift converges more cleanly. SPSA wins when $N$ is so large that even one full parameter-shift gradient is impractical (e.g., $N \sim 10{,}000+$). For $N \sim 100$, parameter-shift is the right default. The crossover depends on the specific noise structure and optimization landscape.

Where this goes next

Tutorial 40 covers quantum natural gradient — using the Fisher information matrix to scale parameter updates by the local geometry of the parameter space. Combined with parameter-shift gradients, quantum natural gradient is the most powerful known optimizer for variational quantum algorithms in 2026, and it offers a partial mitigation for some barren-plateau-adjacent landscapes.

---

Weekly dispatch

Quantum, for people who already code.

One serious tutorial per week, plus the industry moves that actually matter. No hype, no hand-waving.

Email Subscribe

Free. Unsubscribe anytime. We will never sell your email.