Airbus: Quantum Computing for Computational Fluid Dynamics

The Problem

Designing an aircraft wing requires understanding how air flows around it at hundreds of different speed and angle-of-attack combinations. That understanding comes from solving the Navier-Stokes equations: a system of nonlinear partial differential equations governing the velocity, pressure, and temperature of a fluid at every point in space and time.

In practice, engineers discretise the continuous air volume around a wing into a mesh of millions of cells. At each cell, the Navier-Stokes equations reduce to algebraic relationships between adjacent cells. A single steady-state simulation for one flight condition generates a system of tens of millions to hundreds of millions of coupled linear equations that must be solved simultaneously. On a modern HPC cluster with thousands of CPU cores, a high-fidelity full-aircraft simulation takes days. An optimisation study that requires hundreds of such simulations can occupy a cluster for months.

For Airbus, this is not an abstract concern. Reducing aerodynamic drag by 1% on a long-haul aircraft translates to roughly 1% fuel savings over the aircraft’s lifetime, worth hundreds of millions of dollars across a fleet. Faster or higher-fidelity CFD would accelerate design cycles and enable exploration of more radical wing geometries.

The question Airbus investigated: can quantum algorithms for linear systems of equations change the economics of CFD?

The HHL Algorithm

In 2009, Harrow, Hassidim, and Lloyd published an algorithm (HHL) that solves a system of N linear equations Ax = b in time O(log N * kappa^2 * s^2 / epsilon), where kappa is the condition number of A, s is the sparsity, and epsilon is the desired precision. For sparse, well-conditioned systems, this is exponentially faster than the best classical algorithm (O(N) for sparse direct solvers).

The algorithm works in three main stages:

1. State preparation: Encode the right-hand side vector b as a quantum state |b>, with amplitude proportional to each component b_i
2. Quantum phase estimation (QPE): Estimate the eigenvalues of A by simulating the unitary exp(iAt) for various t values using an ancilla register and Hadamard transforms
3. Controlled rotation and uncomputation: Rotate an ancilla qubit by an angle proportional to 1/lambda for each eigenvalue lambda, effectively applying A^-1. Uncompute the phase estimation register.

The output is a quantum state |x> encoding the solution. The exponential speedup comes from working in the exponentially large Hilbert space of the qubit register rather than storing and manipulating an N-dimensional classical vector.

Small-Scale HHL Implementation

Airbus researchers implemented HHL for small linear systems in Qiskit to validate the approach and understand the practical constraints. A 2x2 example illustrates the structure.

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator
import numpy as np

# Solve the 2x2 system Ax = b
# A = [[1.5, 0.5], [0.5, 1.5]]  (symmetric positive definite, condition number 4)
# b = [1, 0]  (encoded as quantum state |0>)
# Analytical solution: x = [0.75, -0.25]

def hhl_2x2():
    # Registers:
    #   nl = 2 qubits for QPE clock register (encodes eigenvalues)
    #   nb = 1 qubit for the b vector (2-dimensional system)
    #   na = 1 ancilla for the controlled rotation
    nl = QuantumRegister(2, 'clock')
    nb = QuantumRegister(1, 'b')
    na = QuantumRegister(1, 'ancilla')
    c  = ClassicalRegister(1, 'result')
    qc = QuantumCircuit(nl, nb, na, c)

    # Step 1: prepare |b> = |0> (already done by default initialisation)
    # For b = [1, 0] the state |0> on nb is correct

    # Step 2: QPE - apply Hadamard to clock register
    qc.h(nl[0])
    qc.h(nl[1])

    # Controlled unitary exp(iAt) and exp(i2At)
    # For this specific A with eigenvalues 1 and 2, we implement
    # the phase kickback directly (in practice, Hamiltonian simulation
    # is used for the general case)
    qc.cp(2 * np.pi * 0.25, nl[0], nb[0])   # exp(iA*t) for t=1
    qc.cp(2 * np.pi * 0.5,  nl[1], nb[0])   # exp(iA*2t) for t=1

    # Inverse QFT on clock register
    qc.h(nl[1])
    qc.cp(-np.pi / 2, nl[0], nl[1])
    qc.h(nl[0])
    qc.swap(nl[0], nl[1])

    # Step 3: controlled rotation on ancilla (1/lambda scaling)
    # Eigenvalue 1 encoded as 01, eigenvalue 2 encoded as 10
    qc.x(nl[1])
    qc.ccx(nl[0], nl[1], na[0])   # ancilla flipped when eigenvalue = 1
    qc.x(nl[1])
    qc.ry(2 * np.arcsin(0.5), na[0])  # rotation angle = arcsin(C/lambda)

    # Uncompute QPE
    qc.swap(nl[0], nl[1])
    qc.h(nl[0])
    qc.cp(np.pi / 2, nl[0], nl[1])
    qc.h(nl[1])

    # Measure ancilla - post-select on |1> to get the solution state
    qc.measure(na[0], c[0])
    return qc

qc = hhl_2x2()
sim = AerSimulator()
counts = sim.run(qc, shots=8192).result().get_counts()
print("Ancilla measurement:", counts)
# Post-selecting on ancilla=1 gives |x> proportional to the solution

This 6-qubit circuit for a 2x2 system requires around 15-20 gates. For an N-dimensional system, the circuit depth scales as O(log N * kappa * s), and the number of qubits scales as O(log N + log kappa). That logarithmic scaling is where the speedup lives.

The Input/Output Problem

HHL’s exponential speedup comes with a catch that is easy to miss in a casual reading of the original paper.

The algorithm outputs a quantum state |x>, not a classical vector x. Reading out all N components of x requires O(N) measurements, destroying the exponential advantage. This is fine if you only need a specific property of x (for example, the drag coefficient, which is a linear functional of the pressure field), but it is a severe limitation if you need to visualise the full flow field or use x as input to the next timestep.

For CFD, the situation is mixed. The quantity engineers most often care about (lift and drag integrated over the wing surface) is a single scalar, in principle accessible via a quantum inner product measurement. But the full velocity field at every mesh point, which is needed for design iteration and flow visualisation, requires classical readout and is not accessible efficiently.

A second problem is state preparation. Encoding the right-hand side vector b into a quantum state with amplitudes proportional to each component b_i requires a circuit of depth O(N) in the worst case, negating the speedup entirely. Specialised state preparation techniques (QROM, sparse encoding) exist for structured vectors, and the Navier-Stokes right-hand side does have structure, but this remains an active and unsolved research problem.

Finally, the condition number kappa of the discretised Navier-Stokes system grows with mesh refinement. At the mesh densities needed for engineering-quality aerodynamic predictions, kappa can reach 10^6 or higher, which makes HHL’s runtime dependence on kappa^2 extremely costly.

Current Honest Assessment

Airbus’s internal review, published in part through their Quantum Computing Challenge, concluded:

• HHL provides a genuine theoretical speedup for sparse, well-conditioned linear systems where only a few output functionals are needed
• For CFD at engineering-relevant mesh densities, the condition number and state preparation overheads currently negate the speedup
• Small-scale demonstrations (4-10 qubit HHL) confirm the algorithm works on hardware but provide no benchmark against classical solvers at those tiny sizes (classical solvers are trivially fast for systems with fewer than 100 variables)
• Fault-tolerant hardware with millions of physical qubits (yielding hundreds of thousands of logical qubits) is required before HHL on realistic CFD problems is conceivable

Researchers at Airbus and elsewhere have proposed problem-specific reformulations (variational linear solvers, quantum-inspired tensor networks) that may offer nearer-term value, but none has yet demonstrated advantage over state-of-the-art classical CFD solvers.

The Airbus Quantum Computing Challenge

In 2019, Airbus launched a public Quantum Computing Challenge, inviting research teams worldwide to propose quantum approaches to five aerospace problems, including CFD, aircraft loading, windshear detection, and satellite mission planning. The CFD track drew submissions from academic groups and quantum software companies.

The challenge produced several promising algorithm proposals and a clearer map of what the hard open problems are. It also established Airbus as one of the more technically serious aerospace companies in quantum computing, publishing detailed problem statements and evaluation criteria rather than vague partnerships.

Results from the challenge are available in Airbus’s published summary reports and associated arXiv preprints.

What Success Would Look Like

If fault-tolerant quantum hardware matures to the point where HHL is practical for large sparse linear systems, the impact on aerospace engineering would be significant.

A full-aircraft aerodynamic simulation that currently requires 48-72 hours on a large HPC cluster could potentially run in hours. This would change the economics of design optimisation: instead of evaluating dozens of wing geometry candidates, engineers could evaluate thousands, including geometries currently ruled out by compute budget. It would also enable higher-fidelity turbulence modelling, which classical methods approximate due to cost.

The more conservative near-term scenario is quantum-classical hybrid: quantum subroutines handle specific inner-loop computations within a classical CFD solver, providing speedup on the parts of the problem where quantum algorithms have provable advantage while keeping the overall workflow classical.

Neither scenario is imminent. Airbus’s own timeline places potential practical quantum advantage in CFD at 10-15 years out, contingent on hardware progress that remains uncertain.

Framework Notes

Airbus researchers have used both Qiskit (for IBM Quantum hardware experiments) and Cirq (for small exploratory implementations on Google Sycamore). The OpenFermion library, primarily aimed at quantum chemistry, also provides useful tools for Hamiltonian simulation routines that underpin HHL’s QPE stage.

Learn more: Qiskit Reference