NISQ Era & Quantum Error Correction

1 The NISQ Era

The term NISQ — Noisy Intermediate-Scale Quantum — was coined by John Preskill in 2018 to describe the quantum hardware available today and in the near future: devices with 50–1000 qubits that are too large to simulate classically yet too noisy to run full fault-tolerant quantum algorithms.

"We have entered a new era of quantum technology. The most advanced quantum computers now have more than 50 qubits — enough to be beyond the reach of exact classical simulation. But they are very noisy. The term 'NISQ' captures both aspects."
— John Preskill, 2018

1.1 Three Generations of Quantum Hardware

1.2 Coherence and Decoherence

The central physical challenge of NISQ hardware is decoherence — the loss of quantum coherence (superposition and entanglement) due to the qubit's interaction with its environment. Qubits are quantum systems that must remain isolated to maintain their quantum state, but perfect isolation is physically impossible.

The physical picture: a qubit in state $\ket{1}$ can spontaneously lose energy to the environment (dropping to $\ket{0}$, governed by $T_1$), and the relative phase between $\ket{0}$ and $\ket{1}$ can randomise due to fluctuating electromagnetic fields (governed by $T_2$). Both processes are irreversible — they cannot be undone by applying a unitary gate.

1.4 Interactive Decoherence Simulator

Observe how a qubit state loses its energy ($T_1$ relaxation towards $\ket{0}$) and loses its phase information ($T_2$ dephasing, shrinking to the Z-axis) over time. Adjust the $T_1$ and $T_2$ times and click "Play".

1.3 DiVincenzo Criteria for Quantum Computing

In 2000, David DiVincenzo articulated five (later expanded to seven) criteria that any physical system must satisfy to be a viable quantum computer. These provide a systematic checklist against which all qubit platforms are evaluated.

2 Variational Quantum Algorithms (VQA)

Given that NISQ devices can only run shallow circuits reliably, the community developed a class of hybrid quantum-classical algorithms called Variational Quantum Algorithms (VQAs). The idea is elegant: use a shallow parameterised quantum circuit to prepare a trial quantum state (cheaply, on the noisy device), estimate a cost function from measurements (also on the quantum device), and then update the parameters using a classical optimiser (on a classical computer). The quantum device does what it's good at (state preparation and expectation values); the classical computer does what it's good at (parameter updates).

2.1 The Hybrid Loop — "Co-stewarding" the Problem

Think of a VQA as a constant conversation between a quantum device and a classical computer.

2.2 The Cost Function

A good VQA cost function must satisfy three properties:

• Faithful: The minimum of $C(\theta)$ corresponds to the solution of the problem. For VQE: $C(\theta) = \langle\psi(\theta)|H|\psi(\theta)\rangle$, minimised when $\ket{\psi(\theta)}$ is the ground state of $H$, by the variational principle.
• Estimable: $C(\theta)$ can be estimated efficiently from measurements on the quantum device. This typically requires expressing $H$ as a sum of Pauli strings and measuring each term separately.
• Trainable: The gradient $\nabla_\theta C(\theta)$ must be efficiently computable (not exponentially small — the barren plateau problem, discussed below).

2.3 Ansatz Design

2.4 The Parameter-Shift Rule: Computing Gradients on Quantum Hardware

A key challenge: you cannot compute derivatives numerically (finite differences) on a quantum computer without many shots of noise. The parameter-shift rule provides an exact gradient evaluation using only two circuit evaluations per parameter.

2.5 Classical Optimizers for VQAs

The classical optimizer takes gradient information (from the parameter-shift rule) and updates the parameters. The choice of optimizer significantly affects VQA performance.

• Gradient Descent (SGD): $\theta_{t+1} = \theta_t - \eta \nabla C(\theta_t)$. Simple but slow convergence; sensitive to learning rate $\eta$. Stochastic version (mini-batches of measurements) helps.
• SPSA (Simultaneous Perturbation Stochastic Approximation): Approximates the gradient using only 2 measurements (regardless of the number of parameters) by simultaneously perturbing all parameters randomly. Particularly useful when measurement cost is the bottleneck. $$\hat{g}_k(\theta) = \frac{C(\theta+c_k\Delta_k) - C(\theta-c_k\Delta_k)}{2c_k}\Delta_k^{-1}$$ where $\Delta_k$ is a random $\pm 1$ vector and $c_k\to 0$.
• Quantum Natural Gradient (QNG): The quantum analogue of natural gradient descent, which uses the quantum geometric tensor (related to the Fubini–Study metric on the space of quantum states) as a preconditioning matrix: $$\theta_{t+1} = \theta_t - \eta \,g^{-1}(\theta_t)\,\nabla C(\theta_t)$$ where $g_{ij} = \text{Re}\left[\langle\partial_i\psi|\partial_j\psi\rangle - \langle\partial_i\psi|\psi\rangle\langle\psi|\partial_j\psi\rangle\right]$ is the quantum Fisher information metric. QNG is more expensive per step but often converges in far fewer iterations.
• Adam / RMSProp: Adaptive moment-based optimizers from classical ML, widely used in practice. Adam maintains moving averages of gradients and squared gradients, providing adaptive per-parameter learning rates.

3 Variational Quantum Eigensolver (VQE)

3.1 Quantum Chemistry Motivation

3.2 Fermion-to-Qubit Encodings

Qubits are spin-$1/2$ objects. Fermions (electrons) obey anti-commutation relations. We need a mapping from fermionic operators to qubit operators. There are three main encodings:

3.3 The VQE Hybrid Loop — Step by Step

1. Hartree-Fock (HF) Initial State: Prepare the reference state $\ket{\text{HF}}$ (a product state — the quantum chemistry starting approximation) by initialising certain qubits to $\ket{1}$ (representing occupied orbitals) and others to $\ket{0}$ (unoccupied).
2. Apply Ansatz: Run the parameterised circuit $U(\theta)$ to prepare $\ket{\psi(\theta)} = U(\theta)\ket{\text{HF}}$.
3. Pauli Decomposition: The Hamiltonian $H = \sum_k c_k P_k$ where each $P_k$ is a tensor product of Pauli operators. Measure $\langle P_k\rangle = \langle\psi(\theta)|P_k|\psi(\theta)\rangle$ for each $k$ by appropriate basis rotations.
4. Estimate Energy: $E(\theta) = \sum_k c_k \langle P_k\rangle$.
5. Compute Gradient: Apply the parameter-shift rule for each $\theta_i$: run two shifted circuits, compute $\partial E / \partial \theta_i$.
6. Classical Update: Update $\theta$ using chosen optimizer (Adam, SPSA, QNG).
7. Repeat until convergence ($|\Delta E| < \epsilon$).

from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import JordanWignerMapper
from qiskit_nature.second_q.circuit.library import UCCSD, HartreeFock
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import SPSA
from qiskit.primitives import Estimator

# 1. Define the molecule
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
                     basis='sto3g')
problem = driver.run()

# 2. Map to qubit Hamiltonian (Jordan-Wigner)
mapper = JordanWignerMapper()
qubit_op = mapper.map(problem.second_q_ops()[0])

# 3. Set up ansatz and HF reference state
num_particles = problem.num_particles
num_spatial_orbitals = problem.num_spatial_orbitals

hf_state = HartreeFock(num_spatial_orbitals, num_particles, mapper)
ansatz   = UCCSD(num_spatial_orbitals, num_particles, mapper,
                 initial_state=hf_state)

# 4. Classical optimizer
optimizer = SPSA(maxiter=300)

# 5. Run VQE
estimator = Estimator()
vqe = VQE(estimator, ansatz, optimizer)
result = vqe.compute_minimum_eigenvalue(qubit_op)

print(f"VQE ground state energy: {result.eigenvalue:.6f} Ha")
print(f"Exact  ground state energy (FCI): -1.137270 Ha")
print(f"Error: {abs(result.eigenvalue - (-1.137270))*1000:.2f} mHa")

3.4 VQE Cost Landscape Visualizer

For a single-parameter VQE (e.g., $H_2$ with UCCSD giving one free parameter $\theta$), the cost function $E(\theta) = \langle\psi(\theta)|H|\psi(\theta)\rangle$ has a single-valley landscape. Below: drag to explore how the energy depends on $\theta$.

4 NISQ Challenges

4.1 Barren Plateaus — The Gradient Vanishing Problem

Geometrically: the cost function is like a nearly flat landscape with a tiny, exponentially deep well at the minimum. With exponentially small gradients, the optimizer cannot tell which direction to step.

Why does this happen? A sufficiently deep random parameterised circuit generates states that are, for all practical purposes, uniformly random in the exponentially large Hilbert space. (Technically, the circuit forms a unitary 2-design — it mimics drawing a unitary matrix uniformly at random from the group $U(2^n)$. The uniform distribution over this group is called the Haar measure, so the output state is called "Haar-random".) In such a uniformly random state, the expectation value of any observable is essentially constant ($\approx \tr(H)/2^n$) almost everywhere, and fluctuations are exponentially suppressed by the Hilbert space dimension $d=2^n$. In plain terms: after enough random rotations, you're equally likely to be anywhere in Hilbert space, so the landscape looks flat from every direction.

4.2 Interactive VQA Optimizer Simulator

The simulator below lets you run gradient descent on a toy cost landscape $C(\theta) = \cos\theta + 0.3\sin 2\theta$ — representative of a single-parameter VQE. Adjust the learning rate and noise level (simulating shot noise on gradient estimates via the parameter-shift rule) and watch the optimizer trajectory.

4.3 Measurement Efficiency

A Hamiltonian with $N_s$ spin-orbitals decomposes into $O(N_s^4)$ Pauli terms after Jordan-Wigner encoding. For $N_s = 100$: that's $10^8$ Pauli terms, each requiring many shots (measurements) to estimate. This is a severe practical bottleneck.

4.4 Hardware Noise and Error Mitigation

Unlike error correction (which removes errors entirely but requires many physical qubits per logical qubit), error mitigation reduces the impact of noise on expectation values without full error correction overhead. These are post-processing techniques applied to the measurement outcomes.

5 Quantum Generative Adversarial Networks (qGANs)

5.1 Classical GAN Recap

More formally, a classical GAN (Goodfellow et al., 2014) consists of two neural networks trained adversarially:

• Generator $G$: Takes random noise $z \sim p_z$ and outputs fake data $G(z)$ that tries to imitate the true data distribution $p_\text{data}$.
• Discriminator $D$: Takes a sample (real or fake) and outputs a probability that it's real. Tries to distinguish $p_\text{data}$ from $G(z)$.

They are trained with a minimax objective:

At equilibrium (so-called Nash equilibrium — neither player can improve by changing strategy), the generator perfectly replicates the data distribution and the discriminator cannot distinguish real from fake ($D = 1/2$ everywhere).

5.2 Quantum GAN Structure

A qGAN (Zoufal et al. 2019, IBM Research) replaces the classical generator with a parameterised quantum circuit — the quantum generator. The discriminator can be classical or quantum (most practical implementations use a classical neural network discriminator).

• Quantum Generator: A VQA circuit $G(\theta)$ that prepares a quantum state $\ket{\psi(\theta)}$. Measuring this state produces samples from a distribution $p_G(x;\theta)$ over bitstrings $x \in \{0,1\}^n$.
• Classical Discriminator $D_\phi$: A neural network (parameterised by $\phi$) that takes a sample (from either $p_\text{data}$ or $p_G$) and outputs a probability that it's real.

The training alternates:

1. Fix $\theta$, update $\phi$ to maximise $D$'s ability to discriminate (classical gradient ascent on the discriminator objective).
2. Fix $\phi$, update $\theta$ (using parameter-shift rule on the quantum circuit) to minimise the discriminator's success — i.e., make the generator's samples indistinguishable from real data.

5.3 Financial Application: Option Pricing

More precisely: a European call option on an asset $S$ pays $\max(S_T - K, 0)$ at expiry $T$, where $K$ is the strike price and $S_T$ is the asset price at expiry. The option price is the discounted expected payoff: $$C = e^{-rT}\,\mathbb{E}[{\max(S_T - K,\, 0)}]$$ where $r$ is the risk-free rate (the return you'd get from a "safe" investment like government bonds — it sets the baseline for discounting future cash flows to their present value).

In the qGAN approach (Zoufal et al. 2019, Stamatopoulos et al. 2020):

1. Train a qGAN to reproduce the log-normal return distribution of the underlying asset.
2. Load the trained quantum generator's output state into an amplitude estimation circuit.
3. Use Quantum Amplitude Estimation (QAE) — a quantum algorithm that estimates $\mathbb{E}[f(X)]$ for a quantum-prepared distribution $p(X)$ in $O(1/\epsilon)$ queries (vs $O(1/\epsilon^2)$ for Monte Carlo). This is a quadratic speedup.

from qiskit_finance.circuit.library import LogNormalDistribution
from qiskit_finance.applications.estimation import EuropeanCallPricing
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.primitives import Sampler

# Asset model parameters (log-normal distribution)
S   = 2.0        # spot price
vol = 0.4        # volatility
r   = 0.05       # risk-free rate
T   = 40/365     # time to expiry (40 days)
K   = 2.0        # strike price

# Encode log-normal distribution into quantum circuit
num_qubits = [3]  # 3 qubits → 8 discretisation points
mu    = ((r - 0.5*vol**2)*T + np.log(S))
sigma = vol*np.sqrt(T)
mean  = np.exp(mu + sigma**2/2)
var   = (np.exp(sigma**2)-1)*np.exp(2*mu + sigma**2)
low, high = 0, 3*np.sqrt(var) + mean

distribution = LogNormalDistribution(num_qubits, mu=mu, sigma=sigma**2,
                                     bounds=(low, high))

# Set up option pricing circuit
european_call = EuropeanCallPricing(num_qubits,
                                    strike_price=K,
                                    rescaling_factor=0.25,
                                    bounds=(low, high),
                                    uncertainty_model=distribution)

# Quantum Amplitude Estimation for the expected payoff
iae = IterativeAmplitudeEstimation(epsilon_target=0.01, alpha=0.05,
                                   sampler=Sampler())
problem = EstimationProblem(state_preparation=european_call,
                            objective_qubits=[3],
                            post_processing=european_call.post_processing)
result = iae.estimate(problem)
price  = result.estimation_processed * np.exp(-r*T)
print(f"Estimated option price: {price:.4f}")

5.4 QAOA and the Full VQA Family

The Quantum Approximate Optimisation Algorithm (QAOA), introduced by Farhi, Goldstone, and Gutmann (2014), is the leading VQA for combinatorial optimisation problems — finding the assignment of binary variables that minimises a cost function $C(x)$, $x \in \{0,1\}^n$.

QAOA alternates between two unitaries for $p$ layers:

• Cost unitary: $U_C(\gamma) = e^{-i\gamma C}$ — applies the cost Hamiltonian (encodes the problem)
• Mixing unitary: $U_B(\beta) = e^{-i\beta B}$ where $B = \sum_j X_j$ — explores the solution space

The $2p$ parameters $(\gamma_1,\ldots,\gamma_p,\beta_1,\ldots,\beta_p)$ are classically optimised to maximise $\langle C\rangle$. At $p\to\infty$, QAOA converges to the true optimal solution via adiabatic evolution. For finite $p$, it produces an approximation with a provable approximation ratio for some problems (e.g., MaxCut on 3-regular graphs: ratio $\ge 0.6924$ at $p=1$).

The VQA family covers a wide range of problem domains:

6 Quantum Error Correction (QEC)

Variational algorithms (VQE, QAOA, qGANs) try to work with noise — using shallow circuits and error mitigation to reduce its effects. But for fault-tolerant quantum computing (Shor's algorithm, full quantum simulation), we need to eliminate errors entirely — or rather, suppress them to arbitrarily low levels using quantum error correction.

6.1 Quantum Noise Model — Kraus Operators

Any physical noise process on a qubit can be described as a quantum channel — a completely positive, trace-preserving (CPTP) map on the density matrix $\rho$, expressed in terms of Kraus operators $\{K_i\}$: $$\mathcal{E}(\rho) = \sum_i K_i \rho K_i^\dagger, \qquad \sum_i K_i^\dagger K_i = I$$

6.2 Pauli Decomposition of Errors

Any single-qubit error can be decomposed in the Pauli basis $\{I, X, Y, Z\}$:

• $X$ error (bit flip): $\ket{0}\leftrightarrow\ket{1}$ — the quantum analogue of a classical bit flip
• $Z$ error (phase flip): $\ket{0}\to\ket{0}$, $\ket{1}\to-\ket{1}$ — no classical analogue
• $Y = iXZ$ error: simultaneously a bit flip and a phase flip
• $I$ error: no error

The most common NISQ noise model is the depolarizing channel: $$\mathcal{E}(\rho) = (1-p)\rho + \frac{p}{3}(X\rho X + Y\rho Y + Z\rho Z)$$ With probability $1-p$, nothing happens. With probability $p/3$ each, an $X$, $Y$, or $Z$ error occurs.

6.2 Quantum Hamming Bound

However, the 5-qubit code is complex to implement. We first study the simpler 3-qubit bit-flip code, which corrects only $X$ errors (bit flips) but not $Z$ errors (phase flips). The full correction of both requires the 9-qubit Shor code or the 7-qubit Steane code.

6.3 The 3-Qubit Bit-Flip Code — Complete Analysis

6.4 Interactive Syndrome Demo

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister

def bit_flip_code_circuit(error_qubit=None):
    """
    3-qubit bit-flip error correction code.
    error_qubit: 0, 1, or 2 (which qubit to flip), or None.
    Returns full encode → error → syndrome → correct circuit.
    """
    # Registers
    data    = QuantumRegister(3, 'data')
    ancilla = QuantumRegister(2, 'anc')    # syndrome ancillas
    c_syn   = ClassicalRegister(2, 'syn')  # syndrome measurements

    qc = QuantumCircuit(data, ancilla, c_syn)

    # ── Step 1: Prepare logical |+⟩_L (for testing)
    qc.h(data[0])          # data[0] = α|0⟩ + β|1⟩

    # ── Step 2: Encode into logical code space
    qc.cx(data[0], data[1])    # |ψ⟩|0⟩ → |ψ⟩|ψ₀⟩
    qc.cx(data[0], data[2])    # complete encoding: α|000⟩ + β|111⟩
    qc.barrier()

    # ── Step 3: Inject error (simulating noise)
    if error_qubit is not None:
        qc.x(data[error_qubit])   # bit flip on specified qubit
    qc.barrier()

    # ── Step 4: Syndrome measurement
    # Measure Z₁Z₂: parity of data[0] and data[1]
    qc.cx(data[0], ancilla[0])
    qc.cx(data[1], ancilla[0])
    # Measure Z₂Z₃: parity of data[1] and data[2]
    qc.cx(data[1], ancilla[1])
    qc.cx(data[2], ancilla[1])
    qc.measure(ancilla, c_syn)
    qc.barrier()

    # ── Step 5: Classical feedback correction
    # syn=01 → error on qubit 0; syn=11 → error on qubit 1; syn=10 → error on qubit 2
    with qc.if_test((c_syn[0], 1)):
        with qc.if_test((c_syn[1], 0)):
            qc.x(data[0])   # syndrome 01 → flip qubit 0
    with qc.if_test((c_syn[0], 1)):
        with qc.if_test((c_syn[1], 1)):
            qc.x(data[1])   # syndrome 11 → flip qubit 1
    with qc.if_test((c_syn[0], 0)):
        with qc.if_test((c_syn[1], 1)):
            qc.x(data[2])   # syndrome 10 → flip qubit 2

    return qc

# Test all error cases
for eq in [None, 0, 1, 2]:
    qc = bit_flip_code_circuit(error_qubit=eq)
    print(f"Error on qubit {eq}: {qc.depth()} gate depth")

6.5 The Phase-Flip Code and the Shor 9-Qubit Code

The 3-qubit bit-flip code corrects $X$ errors (bit flips) but is powerless against $Z$ errors (phase flips). Why? Because $\ket{000}$ and $\ket{111}$ are eigenstates of $Z_1Z_2$ and $Z_2Z_3$ — a $Z$ error doesn't change any parity syndrome.

The Shor code is not the most efficient (it uses 9 qubits; the [[5,1,3]] perfect code does the same with just 5), but it was the first to demonstrate that fault-tolerant quantum computation is theoretically possible — paving the way for the entire field of quantum error correction.

6.6 Fault Tolerance and the Threshold Theorem

Current leading architectures for fault-tolerant quantum computation:

• Surface Code: A 2D array of physical qubits with nearest-neighbor interactions only. Threshold $\sim 1\%$ — the highest known for practically implementable codes. Requires ~1000 physical qubits per logical qubit for $p_L \sim 10^{-15}$. Currently the frontrunner for superconducting qubit platforms (Google, IBM).
• Steane Code [[7,1,3]]: Encodes 1 logical qubit in 7 physical qubits with distance 3 (corrects any single-qubit error). A CSS (Calderbank-Shor-Steane) code — simpler to understand theoretically, but lower threshold (~$10^{-4}$).
• 5-Qubit Perfect Code [[5,1,3]]: The smallest code that corrects any single-qubit error. Uses 5 physical qubits; saturates the quantum Hamming bound.

6.7 The Roadmap to Fault Tolerance

The path from today's NISQ machines to a truly useful quantum computer involves one massive hurdle: the Physical-to-Logical Ratio.