CERN: Quantum Classifiers for LHC Particle Event Selection

The Problem

The Large Hadron Collider at CERN produces proton-proton collisions at a rate of 40 million per second. The vast majority are mundane QCD interactions of no particular interest. Rare events like Higgs boson production and decay happen roughly once per billion collisions. A real-time trigger system must classify and discard 99.999% of events in microseconds, retaining only those worth recording for offline analysis.

Offline analysis faces a related problem: given millions of recorded events, identify which contain the signal of interest (such as Higgs to WW decay) versus background processes that mimic the same detector signature. Classical machine learning, specifically boosted decision trees (BDTs) and deep neural networks, has transformed this task over the past decade.

CERN’s quantum computing group, in collaboration with university partners, is investigating whether quantum classifiers can match or exceed classical performance on these event classification tasks, either in accuracy or in parameter efficiency.

Quantum Classifier Architecture

The approach encodes particle jet features (transverse momentum, pseudorapidity, azimuthal angle, isolation metrics) into a parameterized quantum circuit. Measurements on the output state produce a scalar used as the classifier score.

import pennylane as qml
import numpy as np
import torch
from torch import optim

n_qubits = 6
n_layers = 4
dev = qml.device("default.qubit", wires=n_qubits)

def angle_encoding(features, wires):
    """Encode jet features using RY rotations."""
    for i, wire in enumerate(wires):
        qml.RY(features[i], wires=wire)

def variational_layer(params, wires):
    """One layer of rotations and entangling gates."""
    for i, wire in enumerate(wires):
        qml.Rot(params[i, 0], params[i, 1], params[i, 2], wires=wire)
    for i in range(len(wires) - 1):
        qml.CNOT(wires=[wires[i], wires[i + 1]])
    qml.CNOT(wires=[wires[-1], wires[0]])  # wrap-around entanglement

@qml.qnode(dev, interface="torch")
def quantum_classifier(features, weights):
    """Full quantum classifier circuit."""
    # Encode input features
    angle_encoding(features, range(n_qubits))

    # Variational ansatz
    for layer in range(n_layers):
        variational_layer(weights[layer], range(n_qubits))

    # Measure first qubit as binary classifier output
    return qml.expval(qml.PauliZ(0))

# Initialize parameters
weight_shape = (n_layers, n_qubits, 3)
weights = torch.tensor(np.random.uniform(-np.pi, np.pi, weight_shape),
                       requires_grad=True, dtype=torch.float32)

optimizer = optim.Adam([weights], lr=0.01)

def binary_cross_entropy(pred, label):
    prob = (pred + 1) / 2  # map [-1, 1] to [0, 1]
    prob = torch.clamp(prob, 1e-7, 1 - 1e-7)
    return -label * torch.log(prob) - (1 - label) * torch.log(1 - prob)

# Training loop (X_train: jet feature vectors scaled to [0, pi], y_train: 0/1 labels)
def train_step(X_batch, y_batch):
    optimizer.zero_grad()
    losses = []
    for x, y in zip(X_batch, y_batch):
        pred = quantum_classifier(x, weights)
        loss = binary_cross_entropy(pred, y.float())
        losses.append(loss)
    total_loss = torch.stack(losses).mean()
    total_loss.backward()
    optimizer.step()
    return total_loss.item()

The Barren Plateau Problem

A key finding from CERN’s experiments was the severity of the barren plateau problem for deep quantum circuits. As the number of qubits and layers increases, the gradient of the cost function with respect to any single parameter vanishes exponentially. Training effectively halts because there is no gradient signal to follow.

For 4-qubit circuits with 2 layers, gradients were measurable and training converged. At 8 qubits and 4 layers, gradient magnitudes dropped by two to three orders of magnitude and training required thousands of iterations with specialized initialization strategies.

This is not unique to CERN’s application. It is a structural property of parameterized quantum circuits with global cost functions and random initialization. Mitigation strategies (local cost functions, structured initialization, layerwise training) partially alleviate the problem but add complexity.

Results

CERN tested quantum classifiers on simulated LHC data for Higgs to WW signal versus QCD dijet background:

• 4-qubit QNN (2 layers, 24 parameters): AUC 0.71, matching a classical neural network with 24 parameters
• 8-qubit QNN (4 layers, 96 parameters): AUC 0.74, similar to classical MLP with same parameter count; training required careful initialization to avoid barren plateaus
• Classical BDT (XGBoost, 500 trees): AUC 0.83, trained on the same features
• Classical deep NN (5 layers, 10k parameters): AUC 0.86

The quantum classifiers were competitive with classical models of the same parameter count but were substantially outperformed by classical models at practical scale. There was no evidence that quantum circuits captured features classical methods missed.

What’s Next

CERN’s quantum ML group contributed open benchmark datasets derived from simulated LHC physics (available via the HEP quantum ML benchmarks repository) and continues to investigate:

1. Quantum graph neural networks: Particle physics events are naturally graph-structured (jets as particle clouds). Quantum graph circuits may encode this structure more naturally than flat feature vectors
2. Hybrid quantum-classical architectures: Using quantum circuits as specialized sub-modules within larger classical networks, targeting specific sub-tasks where quantum processing may help
3. Hardware experiments: Running small-scale classifiers on IBM Quantum devices to validate that simulation results hold on real hardware

Learn more: PennyLane Reference