⚛️ high-energy experiments

A 1-bit quantum filter for particle trajectory reconstruction

This paper introduces the 1-Bit Quantum Filter, a resource-efficient quantum algorithm that reformulates particle tracking as binary ground-state filtering to achieve $O(\sqrt{N} \log N)$ gate complexity, enabling realistic LHC event reconstruction on current Noisy Intermediate Scale Quantum (NISQ) hardware.

Original authors: Xenofon Chiotopoulos, Davide Nicotra, George Scriven, Kurt Driessens, Marcel Merk, Jochen Schütz, Jacco de Vries, Mark H. M. Winands

Published 2026-08-10

📖 8 min read🧠 Deep dive

CC BY 4.0

Original authors: Xenofon Chiotopoulos, Davide Nicotra, George Scriven, Kurt Driessens, Marcel Merk, Jochen Schütz, Jacco de Vries, Mark H. M. Winands

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to solve a massive, chaotic jigsaw puzzle, but instead of picture pieces, you have thousands of tiny, glowing dots scattered across a dark room. Every time you turn on the lights, a new explosion of dots appears, and your job is to figure out which dots belong together to form a single, straight line. This is the daily reality for scientists studying the subatomic world. They use giant machines called particle accelerators to smash atoms together, creating a shower of new particles that fly out in all directions. Detectors catch these particles as tiny "hits," and physicists must reconstruct their paths to understand what happened.

The problem is that as these machines get more powerful, they create so many particles at once that the number of possible ways to connect the dots becomes astronomical. It's like trying to find the right thread in a haystack that keeps growing faster than you can search it. Traditional computers are getting tired; they have to check every single possibility one by one, which takes too much time and energy. This is where quantum computers enter the story. Think of a quantum computer not as a faster calculator, but as a magical detective that can look at all the possible connections at the same time. However, using this magic has been tricky because the "spells" (algorithms) needed to solve these puzzles were too long and complicated for today's noisy, imperfect quantum machines.

This paper introduces a clever new trick called the "1-Bit Quantum Filter" to solve this specific puzzle. Instead of trying to calculate the exact position of every single particle with perfect precision—a task that is too heavy for current technology—the researchers realized they only need to know if a path is "valid" or "noise." They designed a filter that acts like a bouncer at a club: it checks if a group of dots forms a straight, sensible line (the signal) or if it's just a random jumble (the noise). If it's a straight line, the bouncer lets it in; if it's noise, it gets kicked out. The team tested this idea using computer simulations of real particle collisions and found it works incredibly well, finding the right paths 94.2% of the time, which is just as good as the best methods used today. They also ran the experiment on actual quantum computers, showing that while the technology is still young and struggles with very large puzzles, this new filter is a promising step toward solving the massive data challenges of the future.

The Puzzle of the Glowing Dots

In the world of high-energy physics, scientists smash protons together at nearly the speed of light. When these collisions happen, they create a burst of new particles that fly out in straight lines. Detectors record where these particles pass, creating a cloud of "hits." The challenge is to connect these hits to reconstruct the original paths, or "tracks," of the particles.

As the Large Hadron Collider (LHC) moves into its High-Luminosity phase, the number of collisions will skyrocket. Imagine a room where, instead of a few people walking in a straight line, thousands of people are running around, leaving a trail of glowing footprints. Your job is to figure out which footprints belong to the same person. With so many people, the number of possible ways to connect the footprints grows so fast that even the world's most powerful supercomputers might struggle to keep up. They have to check billions of combinations, which takes too long for real-time decisions.

The Old Way vs. The New Filter

For a while, scientists thought quantum computers could solve this by using a famous algorithm called HHL (Harrow-Hassidim-Lloyd). Think of HHL as a master key that can unlock the exact solution to a massive math problem instantly. However, to use this key, you need a very long, delicate chain of operations. On today's quantum computers, which are still a bit "noisy" and prone to errors, this chain is too long. The noise breaks the chain before the job is done.

The authors of this paper realized that for particle tracking, we don't actually need the exact math solution. We don't need to know the precise angle of every single step; we just need to know if a path is "straight enough" to be real. It's like trying to find a straight line drawn on a piece of paper that's covered in scribbles. You don't need to measure the line to the micrometer; you just need to ignore the scribbles and find the line.

So, they created the 1-Bit Quantum Filter. Instead of doing a complex, high-precision calculation, this filter uses a simple "yes or no" check. It asks: "Is this group of hits a valid track?" If the answer is yes, it keeps it. If the answer is no (it's just random noise), it throws it away.

How the Magic Works

The researchers turned the problem into a game of finding the "ground state," which is a fancy way of saying the most stable, lowest-energy configuration. In their quantum game, valid tracks are like a calm, quiet room, while random noise is like a chaotic, noisy room.

The Setup: They prepare a quantum computer to look at all possible connections between the hits at once.
The Filter: They use a special "time evolution" step. Imagine spinning a coin. If the coin is a valid track, it spins in a way that lands on "Heads" (Signal). If it's noise, it spins in a way that lands on "Tails" (Noise).
The Magic Trick: By carefully choosing how long they let the coin spin, they ensure that the "Noise" coins always land on Tails and get filtered out, while the "Signal" coins have a chance to land on Heads.
The Result: They measure the result. If they see a "Heads," they know they found a real track. If they see "Tails," they know it was just noise.

This approach is much simpler than the old HHL method. It requires fewer steps (gates) and is less sensitive to the noise that plagues current quantum computers.

What They Found

The team tested their idea in two ways:

Simulations: They ran the algorithm on powerful classical computers simulating a noise-free quantum machine. They used realistic data from the LHCb experiment, which includes up to 1,000 particle hits in a single event.
- The Result: The filter found the correct tracks 94.2% of the time. This is almost exactly the same performance as the best classical methods used today (which get about 94.8%).
- The Catch: The filter did produce a few "fake" tracks (about 5% to 13% of the time), whereas the classical method was slightly better at avoiding these. The authors suggest that adding a few more rules to the filter could fix this.
Real Hardware: They ran the algorithm on two actual quantum computers: one from IBM (using superconducting circuits) and one from Quantinuum (using trapped ions).
- The Result: For small problems (about 4 particle tracks), the quantum computers worked well. The Quantinuum machine, which has a more flexible design allowing any qubit to talk to any other qubit, performed better than the IBM machine.
- The Limit: As the problem got bigger (more tracks), the noise on the hardware became too strong, and the signal got lost. This is expected for today's "Noisy Intermediate-Scale Quantum" (NISQ) devices.

Why This Matters

This paper doesn't claim to have solved the entire problem of particle tracking on quantum computers today. Instead, it shows a promising path forward. By simplifying the math from "calculate everything perfectly" to "filter out the noise," they made the problem small enough to be solvable on current hardware.

The authors suggest that in the future, as quantum computers get better and less noisy, this 1-Bit Filter could be a key part of a hybrid system. It could act as a fast, efficient filter to clean up the data before classical computers do the heavy lifting. This could be crucial for the future of the High-Luminosity LHC, where the data volume will be so huge that traditional methods might fail.

In short, the researchers didn't just try to make a faster calculator; they built a smarter filter. And while the filter is still a bit rough around the edges, it proves that quantum computers might one day help us see the invisible lines in a storm of particles.

Technical Summary: A 1-Bit Quantum Filter for Particle Trajectory Reconstruction

Problem Statement
The transition to the High-Luminosity Large Hadron Collider (HL-LHC) presents a severe computational bottleneck for particle track reconstruction. As collision rates increase, the combinatorial complexity of identifying valid particle trajectories from detector hits grows factorially, potentially outpacing classical computing resources. While quantum algorithms like Harrow-Hassidim-Lloyd (HHL) offer theoretical speedups for linear systems, their standard implementation requires prohibitive circuit depths due to high-precision Quantum Phase Estimation (QPE) and extensive ancilla qubit requirements, rendering them infeasible for current Noisy Intermediate-Scale Quantum (NISQ) devices. Furthermore, existing quantum approaches, such as Quantum Annealing or quantum Graph Neural Networks, face challenges regarding training latency or resource intensity.

Methodology
The authors propose a "1-Bit Quantum Filter," a domain-specific adaptation of the HHL algorithm tailored to the binary nature of particle track finding. Instead of performing a resource-intensive, high-precision matrix inversion to determine exact solution amplitudes, the method reformulates the problem as a spectral filtering task to distinguish "signal" (valid track segments) from "noise" (combinatorial background).

Key methodological components include:

Hamiltonian Formulation: The track finding problem is mapped to the ground-state search of an Ising-like Hamiltonian ( $H$ ), adapted from the Denby-Peterson model. The system is defined by binary variables representing track segments (doublets). The Hamiltonian includes angular terms ( $H_{ang}$ ) to reward straight connections, and regularization terms ( $H_{spec}$ , $H_{gap}$ ) to enforce constraints. This discrete optimization is relaxed into a linear system $Ax=b$, where $A$ is a positive semi-definite matrix derived from the Hamiltonian couplings.
1-Bit Quantum Filter: The algorithm replaces the multi-qubit QPE and controlled rotation of standard HHL with a single-ancilla spectral threshold. By selecting a specific evolution time $t = \pi/\lambda_c$ (where $\lambda_c$ is the eigenvalue associated with noise states), the algorithm exploits phase aliasing. This setup ensures that noise eigenstates project to a specific phase that is filtered out, while signal eigenstates (valid tracks) are preserved.
Direct Structural Synthesis (DSS): To implement the required time evolution $e^{-iAt}$ without the overhead of Trotterization, the authors employ a DSS method. This synthesizes exact unitary operators by decomposing the Hamiltonian into diagonal and off-diagonal interaction terms, utilizing a ladder of CNOT gates and multi-controlled rotations to enforce the specific graph topology of the track segments.
Filtration Logic: The circuit utilizes a single ancilla qubit and a 1-bit time register. Through a sequence of state preparation, 1-bit phase estimation, conditional logic (Zero-Controlled NOT), and uncomputation, the algorithm deterministically filters out the noise subspace. Post-selection on the ancilla state $|1\rangle_A$ yields a state composed strictly of valid track segments.

Key Contributions

Algorithmic Reformulation: The paper introduces a shift from exact matrix inversion to binary ground-state filtering, reducing the algorithm's reliance on high-precision QPE and extensive ancilla registers.
Complexity Reduction: The authors derive an asymptotic two-qubit gate complexity of $O(\sqrt{N} \log N)$ and a sampling complexity of $O(N \log N)$ , where $N$ is the number of candidate track segments. This represents a polynomial speedup over classical exhaustive search and eliminates the condition number dependence found in standard HHL.
Hardware Benchmarking: The approach is validated on both noiseless statevector simulators and physical quantum hardware: the Quantinuum System Model H2 (trapped-ion) and the IBM Heron R3 (superconducting).
Realistic Event Validation: The algorithm is tested on realistic LHCb Monte Carlo (MC) events containing up to 1,000 detector hits, comparing performance against the classical "Search by Triplet" (SBT) algorithm.

Results

Simulation Performance: On realistic LHCb MC events, the 1-Bit Quantum Filter achieved a segment-finding efficiency of 94.2%, which is highly competitive with the classical SBT algorithm's 94.8%. However, the quantum approach exhibited a higher fake rate (5.1%–13.7% vs. 2.9%–3.4% for SBT), attributed to the current Hamiltonian's reliance on a simple angular threshold without additional bifurcation or occupancy penalty terms.
Complexity Validation: Gate count analysis on compiled circuits confirmed the theoretical $O(\sqrt{N} \log N)$ scaling. The Quantinuum architecture demonstrated superior scaling factors due to its all-to-all connectivity, which minimized the need for SWAP gates compared to the limited-connectivity IBM architecture.
Noise Resilience: Benchmarks on physical hardware showed that for small systems (up to 4 tracks and 3 layers), the Quantinuum H2 device maintained higher solution fidelity and Signal Separation Index (SSI) than the IBM Heron R3. Both platforms, however, suffered from intractable gate error accumulation beyond this scale, with signal distinguishability dropping below the noise floor for larger problem sizes.
Sampling Efficiency: The success probability of the filter was shown to scale as $O(1/\sqrt{N})$ , consistent with the derived sampling complexity.

Significance and Claims
The paper claims to establish a viable pathway for quantum particle track reconstruction within the constraints of the NISQ era. By relaxing the requirements of HHL to a binary filtering task, the authors demonstrate that quantum algorithms can solve realistic event topologies on noise-free simulators and small-scale hardware. The work highlights that high-connectivity architectures (like trapped-ion systems) offer a distinct advantage for this specific problem due to reduced circuit depth and error accumulation.

The authors remain modest regarding the immediate scalability to full HL-LHC events, noting that current hardware limitations restrict the solvable problem size to small tracking scenarios. They identify remaining challenges, including the need for efficient readout mechanisms to avoid the $O(N)$ sampling bottleneck and the construction of more sophisticated Hamiltonians to reduce fake rates. The paper concludes that while full end-to-end tracking is not yet achievable on current hardware, the 1-Bit Quantum Filter provides a foundational method for future hybrid classical-quantum implementations, particularly as quantum hardware matures toward fault tolerance.