ABB: Quantum Optimization for Power Grid Fault Diagnosis

The Challenge

When a fault occurs in a high-voltage transmission grid, operators must localize the affected component within seconds to reroute power and prevent cascading failures. Classical fault diagnosis algorithms rely on comparing observed relay trip patterns against pre-computed fault dictionaries or running branch-and-bound search over the combinatorial space of possible fault locations. Both approaches scale poorly as grid topology grows: a modern national grid with thousands of buses and protection devices creates a search space that saturates classical solvers during precisely the high-stress conditions when fast answers are most critical. ABB, the global leader in power grid automation, investigated whether quantum optimization could offer a computationally lighter path to accurate fault localization.

The Quantum Approach

ABB’s research team reformulated fault diagnosis as a quadratic unconstrained binary optimization (QUBO) problem. Each binary variable represented whether a given grid component was faulted, and penalty terms encoded consistency constraints between component fault states and observed relay measurements. This QUBO was then solved using the Quantum Approximate Optimization Algorithm (QAOA) running on IBM’s 127-qubit Eagle processor via the Qiskit Runtime service.

from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
from qiskit_algorithms.minimum_eigensolvers import QAOA
from qiskit_algorithms.optimizers import COBYLA
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator

# Define the fault diagnosis QUBO for a 40-bus grid segment
qp = QuadraticProgram(name="fault_diagnosis_40bus")

# Binary variable per monitored component
n_components = 40
for i in range(n_components):
    qp.binary_var(name=f"fault_{i}")

# Add objective terms from relay observation matrix
for i, j, coeff in relay_coupling_terms:  # pre-computed from grid topology
    qp.minimize(quadratic={(f"fault_{i}", f"fault_{j}"): coeff})

# Convert to QUBO
converter = QuadraticProgramToQubo()
qubo = converter.convert(qp)

# Run QAOA with p=3 layers
service = QiskitRuntimeService()
backend = service.backend("ibm_eagle")
estimator = Estimator(backend=backend)

qaoa = QAOA(estimator=estimator, optimizer=COBYLA(maxiter=200), reps=3)
result = qaoa.compute_minimum_eigenvalue(qubo.to_ising()[0])
fault_assignment = converter.interpret(result)
print("Diagnosed fault locations:", [k for k, v in fault_assignment.items() if v > 0.5])

The team benchmarked QAOA at circuit depth p = 3 against a classical branch-and-bound solver across 200 randomly generated fault scenarios on a synthetic 40-bus IEEE test grid, measuring solution quality and wall-clock time on equivalent hardware generations.

Results and Implications

QAOA achieved solution quality matching the classical branch-and-bound solver in 94% of test scenarios while consuming roughly one-third of the computational time on equivalent hardware. On the 6% of scenarios where QAOA returned a suboptimal assignment, the errors were single-component misclassifications rather than catastrophic mislocalizations, meaning operators would still be guided to the correct grid region.

The 3x overhead reduction is significant in the context of real-time grid operations, where diagnosis windows are measured in seconds. ABB is now integrating the QAOA solver as an optional acceleration module within its Network Manager SCADA platform, with automatic fallback to classical methods when quantum backend availability is uncertain. As quantum hardware error rates continue to decline and deeper QAOA circuits become practical, ABB expects the performance gap to widen further, particularly on larger grid instances where classical scaling breaks down more sharply.