Thales Quantum-Enhanced Radar Signal Processing

The Problem

Radar signal processing is one of the most computationally intensive tasks in modern defense electronics. A phased array radar generates a continuous stream of complex-valued samples across many antenna elements and range bins. Detecting targets against a background of clutter and noise requires algorithms that operate in near real time at high sample rates. The standard approach is a cascade of classical digital signal processing (DSP) operations: fast Fourier transforms for Doppler processing, matched filtering for pulse compression, and constant false alarm rate (CFAR) detection to set adaptive thresholds.

For large synthetic aperture radars and space-based surveillance systems, the data volumes and the need for sub-millisecond detection latency push classical DSP hardware close to its limits. The quantum Fourier transform (QFT) runs in O(n^2) gate operations on n qubits rather than the O(N log N) classical FFT on N = 2^n samples, offering a potentially exponential advantage if the data can be loaded into quantum states efficiently.

Quantum Fourier Transform for CFAR Detection

Thales implemented a QFT-based processing pipeline in Qiskit and validated it on IonQ Harmony hardware. The synthetic radar scenario used 16 complex samples (4 qubits) representing a single range bin Doppler profile. The QFT maps these samples into the frequency domain, revealing Doppler shift signatures of moving targets.

CFAR detection in the quantum circuit is implemented using amplitude estimation: after the QFT, quantum amplitude estimation identifies frequency bins where signal power exceeds a threshold set by the local noise floor. This avoids the need for a full classical readout and thresholding step, which would negate the quantum speedup.

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.library import QFT
from qiskit_ionq import IonQProvider
import numpy as np

# Synthetic radar Doppler profile: 16 samples, single moving target at bin 3
n_qubits = 4  # 2^4 = 16 samples
target_bin = 3
noise_level = 0.05

# Encode normalized signal amplitudes as rotation angles (angle encoding)
# Real radar data requires QRAM; here we construct the state directly
signal = np.zeros(2**n_qubits, dtype=complex)
signal[target_bin] = 1.0  # pure tone target at Doppler bin 3
signal += noise_level * (
    np.random.randn(2**n_qubits) + 1j * np.random.randn(2**n_qubits)
)
signal /= np.linalg.norm(signal)

qr = QuantumRegister(n_qubits, "q")
cr = ClassicalRegister(n_qubits, "c")
qc = QuantumCircuit(qr, cr)

# State preparation: initialize the quantum register with the radar samples
# In practice this is the QRAM loading step; here we use statevector init
qc.initialize(signal, qr)

# Apply QFT to transform to frequency (Doppler) domain
qft = QFT(num_qubits=n_qubits, inverse=False, do_swaps=True)
qc.append(qft, qr)

# Measure: peaks in measurement distribution correspond to target Doppler bins
qc.measure(qr, cr)

print(f"Circuit depth: {qc.depth()}")
print(f"Two-qubit gate count: {qc.num_nonlocal_gates()}")

# Run on IonQ Harmony via cloud access
provider = IonQProvider(token="<API_TOKEN>")
backend = provider.get_backend("ionq_harmony")

job = backend.run(qc, shots=1024)
result = job.result()
counts = result.get_counts()

# Most frequent bitstring should correspond to target_bin in bit-reversed order
dominant_bin = int(max(counts, key=counts.get), 2)
print(f"Detected Doppler bin (bit-reversed): {dominant_bin}")
print(f"Expected target bin: {target_bin}")

The Matched Filter Problem

Beyond Doppler processing, Thales investigated quantum matched filtering for pulse compression. A matched filter correlates the received signal with a replica of the transmitted waveform (the reference chirp). In the frequency domain, matched filtering is a pointwise multiplication, which maps naturally to a quantum phase oracle if both the received signal and the reference chirp can be loaded into quantum superposition.

The circuit applies the QFT to both the received signal and the reference chirp, performs a controlled phase rotation (encoding the pointwise product), and applies the inverse QFT to return to the time domain. The fidelity on IonQ Harmony for 4-qubit pulse compression matched the simulation results to within the expected shot noise, validating the circuit design.

The QRAM Bottleneck

The critical obstacle for practical quantum radar signal processing is quantum random access memory (QRAM). Loading N classical samples into a quantum superposition state requires a QRAM circuit with O(N) components, completely eliminating the exponential advantage of the QFT. Proposed QRAM architectures (bucket-brigade QRAM) recover the advantage in query complexity but require highly coherent ancilla qubits maintained for the duration of the memory access.

At IonQ Harmony’s coherence times and gate fidelities, loading even 16 real radar samples via a full QRAM circuit would accumulate too much error for useful signal processing. Thales concluded that quantum radar processing advantage is contingent on QRAM hardware that does not currently exist, and that current demonstrations must use direct state initialization as a placeholder for the loading step.

Current Gap and Roadmap

Classical GPU-based radar DSP achieves FFTs over millions of samples in microseconds. The 16-sample QFT demonstrated on IonQ Harmony is 4 orders of magnitude smaller than operationally relevant problem sizes. Thales published an internal roadmap placing quantum-classical hybrid signal processing as a 2030+ capability, contingent on both improved QRAM hardware and quantum processors with error rates two orders of magnitude below current levels.

In the near term, Thales identified quantum sensing (not quantum signal processing) as the more tractable application: quantum-enhanced radar receivers using entangled photons or squeezed states for improved receiver sensitivity, without requiring large-scale quantum computation.

Learn more: Qiskit Reference | Quantum Fourier Transform