In collider physics, the endeavor of accurately associating the multitude of hits in the detectors recorded during high-energy particle collisions with the original charged particle tracks that traversed the detector emerges as a particularly challenging combinatorial problem (Chatrchyan et al., 2014; Cerati, 2015). The precise assignment of these detector hits is pivotal for deducing the underlying nature and dynamics that catalyzed the fundamental interactions being probed in such collisions. The critical endeavor of tracking therefore fosters a deeper understanding and elucidation of new physics phenomena, thereby acting as a linchpin in advancing high-energy physics.

The gamut of issues encountered in high-energy physics often resembles database search algorithms, where the solution to a particular problem is embodied as a notable element within a specified dataset. A prime exemplification of this is identifying charged particle tracks within a detector experiment, as seen in the eminent CMS (Chatrchyan et al., 2008) and ATLAS (Aad et al., 2008) experiments at CERN. This task can be conceptualized as a variant of a search algorithm known as template matching. The primary objective is to discern charged particle tracks traversing the tracker detector by juxtaposing the raw detector response against a pre-established database encompassing hit patterns that correspond to physical particle tracks obtained from simulation. Upon the recognition of a physical track within the data, attributes of the track, such as momentum and angular distribution, can be gleaned from the template database. This procedure is prominently recognized as Associative Memory, and has been shown to be a highly effective approach to track finding in high-energy experiments, employing Application Specific Integrated Circuits (ASIC; Dell'Orso and Ristori, 1989) to perform the template matching. The method of template based track finding is used in modern detector experiments (Nicolaidou et al., 2010; Bunkowski, 2019; Collaboration, 2021) and is marked as one of the potential approaches to be used at future colliders.

The proficiency of template matching algorithms is heavily contingent on the efficiency at which one can traverse through the template database. In an unstructured database comprising N elements, conventional search algorithms exhibit a scaling of O(N), necessitating, on average, N/2 queries to the database to pinpoint the matching element. Contemporary particle colliders witness an increase in the number of potential tracks encoded in the database, congruent with the escalating energy and luminosity of the collisions within the detectors. Concurrently, since the advent of advanced tracking technology, tracking detectors have been evolving to become highly granular, thereby amplifying the resolution of the tracks and, consequently, the quanta of track patterns necessitated to be encoded into the template database. As the frontier of high-energy and high-luminosity experiments beckons, the practice of identifying charged particle tracks via Associative Memory is confronted with a duo of challenges: (1) the rapidly increasing number of tracks encoded in the template database demands a significant amplification in storage capacity to accommodate the probable tracks, and (2) the temporal resources required to sift through a burgeoning number of tracks is inefficient for modern tracking objectives.

With its rapid and continuous development, quantum computing offers a paradigm shift in information science and has the potential to revolutionize modern computational techniques. Particle physics will benefit from any speedup that quantum computers can provide and the devices' ability to compute in a regime that has never been accessible before. Already, there has been a quickly developing research effort into proof-of-principle algorithms for applications in particle physics ranging from the simulation of quantum field theories (Jordan et al., 2014; Ciavarella et al., 2021; Kan and Nam, 2021; Paulson et al., 2021; Davoudi et al., 2022; Kane et al., 2022; Fromm et al., 2023) and collision events (Bauer et al., 2021; Bepari et al., 2021, 2022; Gustafson et al., 2022; Li et al., 2022; Barata et al., 2023; Chawdhry and Pellen, 2023), to event classification (Blance and Spannowsky, 2020; Araz and Spannowsky, 2022) and analysis (Mott et al., 2017; Wu et al., 2021). Quantum tracking algorithms have gained a lot of interest (Shapoval and Calafiura, 2019; Bapst et al., 2020; Zlokapa et al., 2021; Duckett et al., 2022; Gray and Terashi, 2022) in an attempt to combat the problems facing classical techniques. Quantum computers offer a solution to the limitations of Associative Memory. The exponentially growing Hilbert space of qubit-based systems allows large datasets to be encoded onto quantum devices with efficient resource usage (Ventura and Martinez, 2000; Shapoval and Calafiura, 2019). Furthermore, it has been shown that a polynomial speedup can be achieved for search algorithms by leveraging the Grover Search Algorithm (Grover, 1996, 1997), which has been suggested as a tool to achieve the crucial speedup required for Associative Memory to be effective for tracking algorithms (Shapoval and Calafiura, 2019).

This paper proposes a proof-of-principle quantum algorithm which extends on the regular Grover search approach to track finding via Associative Memory, proposed in Shapoval and Calafiura (2019), by abstracting the oracle operation to perform a template matching algorithm to match detector-hit data with a pre-established database of physical tracks. Following the oracle construction method of Gao et al. (2022), it will be shown that a single, general oracle operation can be constructed for the template matching approach to successfully identify particle tracks. Additionally, we will demonstrate that the template matching approach further improves on the regular Grover search approach by allowing for data with missing hits to be efficiently reconstructed, a highly non-trivial task for classical tracking algorithms.

The Grover Search is an optimal quantum search algorithm (Grover, 1996, 1997) which amplifies the amplitudes of marked states within a uniformly distributed database to successfully identify elements of interest, achieving a polynomial speedup over classical search techniques for unstructured databases. Consider an unstructured dataset of N elements X = {x₁, x₂, …, x_N} with one or more elements of interest, m_j, which can be encoded onto n = log₂(N) qubits as an equal superposition,

where AG=H⊗n is an n-qubit Hadamard transformation which prepares the state |s〉, and the states |x_i〉 encode the elements x_i in the computational basis on the quantum device. The Grover Search aims to identify the elements of interest, m_j, in the database X and amplify their amplitudes. To first identify the marked elements, one can define a Boolean function, f(x), such that

This function can then be used to construct the oracle,

such that the amplitude of an element of interest is marked by inverting the amplitude of the state and leaving all other states unchanged. Marking the states alone is not enough to successfully identify the elements of interest, as a measurement at this stage will still return each element with equal probability. Therefore, one must amplify the amplitudes of the marked states such that a measurement returns one of the marked states with a high probability. Geometrically, the amplification process can be modeled as a reflection of the whole system about the equal state |s〉 from Equation (1), reducing the amplitudes of the unmarked states, and amplifying the marked states. This can be achieved by applying the Grover diffuser, which has the form

where S₀ is a phase inversion on the zero state, and in the case of the Grover Search, AG†=AG, as the Hadamard transform is Hermitian.

Combining the diffuser with the oracle, one step of the algorithm can be defined as a single, unitary operation, the Grover Iterator,

which can be applied iteratively to amplify the amplitudes of all states of interest in the database. For an unstructured database of N-elements with m-elements of interest, the optimal number of applications of Q to achieve the highest probability of measuring a state of interest is

The Grover Search, therefore, scales as O(N), providing a remarkable polynomial speedup over a classical search algorithm. Consequently, the Grover Search offers a substantial speedup when searching large databases, typical of those produced by modern particle physics experiments.

It should be noted that it is possible to construct a database for which the number of elements of interest, m, is not known a priori. Therefore it is not clear how many iterations of Q should be applied to reliably return an element of interest from the database upon measurement. To establish m, one can use Quantum Counting (Brassard et al., 1998) which leverages Quantum Phase Estimation (Kitaev, 1995) to estimate the number of interesting states in the database, and, by extension, the number of applications of Q. For the examples considered in this paper, the number of elements of interest is known by construction of the database, however future implementations may benefit from the Quantum Counting routine.

Modern high-energy collider experiments collide particles together at unprecedented energies in the center of close-to-fully hermetic detectors. These detectors comprise many sub-detector regions immersed in strong magnetic fields. The experiment aims to precisely reconstruct the energy and momentum of each particle created in the collision event to unveil the underlying physics in play. The reconstruction of a high-energy collision event can be separated into three main steps: (1) the reconstruction of the charged particle trajectories as they traverse the detector layers through particle tracking, (2) the determination of the particle energies using calorimetry, and (3) the reconstruction of muons in dedicated tracking modules on the outer layer of the detector device. From this process, essential characteristics of the underlying physics can be obtained. For example, the particle species can be identified, and any missing energy can be established. This paper will focus on the first step, designing a quantum algorithm to identify charged particle tracks in the detector efficiently.

To successfully record the trajectory of a charged particle within a tracking detector, a method for measuring the particle's position without disturbing its path is required. In state-of-the-art collider experiments such as the CMS (Chatrchyan et al., 2008) and ATLAS (Aad et al., 2008) experiments on the Large Hadron Collider at CERN, sub-millimeter-thick layers of silicon sample a particle's trajectory by recording a hit every time the particle passes through a layer. By applying strong magnetic fields the trajectory of a charged particle can be curved proportionally to the inverse of the particle's momentum. Thus, with a position granularity of tens of micro-meters, the tracking detector can accurately reconstruct the particle's trajectory, allowing for the particle's charge and momentum to be inferred from the track's curvature. Furthermore, the high precision of silicon trackers allows for the accurate reconstruction of jets, cones of high-energy hadrons emerging from the hadronization of color-charged particles resulting from the high-energy collision. Displacements of 100's of micro-meters can be reconstructed, allowing for the individual constituents of the jet to be separately resolved. As a result, the detectors can identify complete decay chains emerging from the high-energy collision event.

In the tracking detectors, the only information collected is the position at which each track traversed a silicon layer. The hits belonging to an individual particle track must, therefore, be identified from the raw detector output. Once identified, a fitting operation is performed to dress the track with parameters such as the azimuthal angle, ϕ, at which the particle has been produced, and the reconstructed transverse momentum, p_T. Due to the wide range of possible interactions, the paths of the charged particles in the tracking detectors vary, and the possible combination of hit patterns they produce is extensive. Furthermore, each hit pattern is associated with many tracks. For example, Figure 2 indicates some of the possible tracks that have the same hit pattern in a simple, 12-module detector. With increasingly granular detectors, the number of possible hit patterns is increasing to unmanageable levels. For a single particle crossing the detector, identifying the hits corresponding to the particle's track is seemingly a trivial task. However, in particle collisions, thousands of charged particles traverse the detector every fraction of a second. Each particle leaves a set of hits in the detector, leading to tens of thousands of hits in the detector from the particle trajectories, all overlapping. Therefore, the reconstruction of particles becomes a highly challenging combinatorial problem. Cerati (2015) highlights the increasing challenge of track reconstruction at high pile-up and presents analysis of reconstruction times for current track reconstruction methods.

Classical techniques such as Associative Memory, which employs a template matching approach to track finding, have been shown to be highly effective at identifying hit patterns in the tracking detectors (Bardi et al., 1998). However, as the number of particles through the detector increases with the collider energy and luminosity, and tracking detectors become more granular, the number of hit patterns that need to be stored and compared becomes increasingly unmanageable, and the time taken to find the correct match grows quickly. With the exponentially growing Hilbert space of a qubit system and the polynomial speedup of Quantum Amplitude Amplification (QAA), quantum computers provide a potentially powerful tool for tackling the track finding problem. In Section 4, a proof-of-principle quantum tracking algorithm is proposed, which harnesses the advantage over the QAA routine. In Section 5, it will be shown that this algorithm can be extended to handle imperfect data which has missing hits efficiently.

To successfully identify tracks in hit data from the detector via a quantum template matching algorithm, the oracle must have a general construction to identify the correct track without prior knowledge of the input data. Following the oracle construction from Gao et al. (2022), it is possible to design a general oracle, S~f, by introducing an additional register to the QAA circuit in Figure 1, the data register. The retrieved detector-hits data from the experiment is encoded on this register for each event with the unitary operation AD. The register retained from the QAA routine will now encode the template database, the template register. For a tracker in the same configuration as Figure 2, with 12 tracker modules arranged in layers of threes, there are 15 possible hit patterns for particles traversing the detector, neglecting multiple track signatures and requiring one hit per detector layer. These hit patterns are one-hot encoded into bit strings of 12 bits, with each bit corresponding to a detector module. If a hit is detected on the module, the bit is flipped to the “1” state. Otherwise, it remains in the “0” state.¹ The templates are encoded onto the template register as a linear superposition of all possible tracks through the unitary operation AT. The individual hit-pattern encodings are displayed in Table 1. The state preparation has the general form

where n = 12 for the example from Figure 2. Ideally, the database of hit-pattern templates would be loaded onto the device from Quantum Random-Access Memory (QRAM; Giovannetti et al., 2008), however limitations on the ability to realize QRAM mean that, currently, the database must be prepared via state preparation. State preparation is a highly non-trivial task, and has been shown to necessitate exponential circuit depths to construct an arbitrary quantum state (Sun et al., 2023). By leveraging ancillary qubits, this scaling can be reduced to polynomial scaling in circuit depth, though at the potential cost of an exponentially growing number of ancillary qubits (Plesch and Brukner, 2011; Zhang et al., 2021, 2022; Rosenthal, 2023). For the algorithm proposed here, the state preparation routine from Qiskit Contributors (2023), which employs a recursive initialization algorithm with optimization (Shende et al., 2006), has been used to load the one-hot encoded track templates onto the device.

To construct the general oracle, S~f, we allow for the oracle to now act across the two registers, controlling from the data register and applying a series of CNOT operations to the template register. If the hit pattern encoded onto the data register is in the template database, then the corresponding state on the template register will be flipped to the zeroth state. The matched state can be marked by applying a phase inversion on the zero state, S₀. Finally, the oracle returns the marked state to its original bit combination by applying the series of CNOT operations again, in the same order, controlling from the data register and acting on the template register. Through this oracle operation, S~f, the track-template matching the hit-pattern encoded on the data register is marked with a negative phase, without the need for a bespoke oracle operation designed for the specific input data. To amplify the marked state, the QAA diffuser from Equation (5) is then applied to the template register, where here A=AT. To achieve the greatest probability of selecting the correct track, the oracle and diffuser are then applied t-times, according to Equation (4). Figure 3 shows a schematic of the circuit for the quantum template matching algorithm, outlining the structure of the oracle explicitly.

Adopting the procedure of the quantum template matching algorithm for track finding allows for data from the detector to be parsed into the quantum algorithm and matched to a track template “on-the-fly,” as the circuit is general for all possible hit patterns handed to the algorithm. The data is one-hot encoded onto the device using the unitary operation AD, which applies a series of NOT-gate operations to load the data onto the device. The efficiency of the track finding algorithm has been tested for two hit patterns, corresponding to Tracks 1 and 5 in Table 1. To successfully determine the matching efficiency, the circuit has been run for three iterations of the QAA routine, and for 10⁴ shots on the qasm_simulator without a noise model.² The results are displayed in Figure 4, showing that the correct match is achieved with high probability, >90% efficiency.

The success in matching the data to the correct hit pattern with very high probability and the QAA routine's polynomial speedup over classical search algorithms means the algorithm is well-suited to the track finding problem. Furthermore, in practice one would only have to run a small number of shots of the circuit to retrieve the correct track match with high probability, and remarkably requiring only one shot of the circuit if the track pattern is known to the be in the database. Therefore, the quantum template matching provides a fast and efficient approach to charged-particle track finding on a quantum device. However, the circuit from Figure 3 requires the data to match precisely with a hit-pattern template in the database. In practice, this is not always the case, as data from the detector may be missing hits from specific tracking modules. In Section 5, it will be shown that, by modifying the oracle S~f, the quantum template matching algorithm can identify possible tracks in imperfect data, a highly non-trivial task for current classical techniques.

One of the primary challenges in track finding via Associative Memory arises when a particle passes through the detector and one or more of the detector modules on its trajectory fails to register a hit. Current, state-of-the-art track-reconstruction techniques struggle with this scenario as the combinatorics between layers with missing hits quickly become unmanageable. Overcoming this problem is paramount as the energy and luminosity of colliders are increasing, and the detectors are becoming more granular, elevating the combinatorial problem. In this Section, the quantum template matching algorithm from Section 4 is extended to allow for the identification of tracks from imperfect data, without an increase in computation complexity or resources.

In the quantum template matching circuit shown in Figure 3, the oracle, S~f, is essential for accurately selecting and marking the identified track by comparing, exactly, the bit strings in the data register and the template register. Consider parsing a hit pattern to the algorithm which does not contain a hit in the third layer of a detector like the one shown in Figure 2. Running the algorithm for many shots would not return a decisive answer to which hit pattern matches the trajectory of the particle through the tracker, as the hit pattern without the third hit is not in the template database. To combat this problem, the oracle can be modified to correctly identify a match in the hit-pattern template database.

Using the example of a hit missing in the third detector layer, we now modify the oracle S~f such that it does not act on the qubits corresponding to the third detector layer, and acts only on the “good” subset of qubits corresponding to the other layers. The modified oracle, S~f′, follows the same form as S~f, but acts only on the good subset of qubits: first, a series of CNOT-operations is applied, controlling from the good subset of qubits in the data register and acting on the corresponding good subset of qubits in the template register. If there is a match, the good subset of qubits in the template register will have been flipped to the zero state. The matching state is then marked using a phase inversion on the zero state, S₀. Finally, the CNOT-operations are reapplied, and the template register is returned to its original state with the exception of any matched state having a negative phase. The oracle S~f′ therefore has the same effect as the oracle S~f from Section 4, but now acting only on the good subset of qubits corresponding to the tracking layers which are operating correctly.

Employing this oracle, S~f′, in the quantum template matching algorithm from Section 4 will return all possible hit-pattern templates with the matching good subset of qubits, allowing for efficient identification of the particle's trajectory through the detector. For the example outlined here, two states corresponding to Tracks 8 and 9 from Table 1 will be marked, therefore Equation (6) states that two iterations of the QAA routine will yield the best match.³ Figure 5 shows the results from 10⁴ shots on the qasm_simualtor for two iterations of the QAA routine using the modified oracle. The algorithm successfully predicts the possible path that the particle could have taken through the tracker, returning correct hit patterns for Tracks 8 and 9 from Table 1. Remarkably, the computational complexity and the required quantum resources do not increase when dealing with imperfect data, which is not the case using classical techniques. On the right of Figure 5, an illustrative number of combinations of tracks passing through the two hit patterns shows how the combinatorics for this problem will increase dramatically for missing-hits data.

In a modern silicon detector the efficiency of each detector module is very high and so missing hits are usually attributed to cooling or power faults, which can be quickly identified during data quality monitoring (Butz, 2018). Therefore, the oracle, S~f′, can be easily modified to ensure efficient tracking by removing the qubits corresponding to the faulty tracker modules from the oracle operation. However, it is not always known which detector modules have failed to record a hit, thus the choice of which part of the data bit-string to examine is not clear. To effectively deal with this situation, the oracle can be modified by randomly removing CNOT-operation controls to correctly identify possible hit-pattern matches in imperfect data to a high level of accuracy. Due to the extreme combinatorics in modern particle collider experiments, this is becoming an unmanageable problem for classical approaches, such as Associative Memory. The algorithm presented here can match both perfect and imperfect data, retrieving the correct match with high probability without any increase in computational complexity or resources for the latter. The simple but effective algorithm, therefore, provides an advantage over classical template matching techniques, both in polynomial speedup and the ability to match data with missing hits. This speedup and accuracy will become necessary as the field moves to an era of higher energies and luminosities.

Charged-track finding in high-energy particle collisions is a complex combinatorial task, fraught with challenges stemming from the sheer volume of data, noise, and intricacies of particle interactions. In this article, we present general and extendable quantum algorithms for the identification of particle tracks through a detector. As an application, a simplified detector model has been used, constructed from 12 detector modules arranged in four layers of three tracking modules. The quantum algorithms employ a novel oracle design to successfully identify particle tracks traversing the detector by matching detector-hit data to a hit-pattern template in a pre-established database of possible hit patterns. By abstracting the Quantum Amplitude Amplification (QAA) routine to encompass an additional data register, the identified template has then been amplified to deliver the correct match upon measurement. Exploiting the established polynomial speedup provided by the QAA routine (Brassard et al., 2002), the quantum template matching algorithm provides an advantage over classical tracking techniques via Associative Memory. Figure 4 contains the results from running the quantum template matching algorithm on the qasm_simulator for 10⁴ shots, showing that data parsed to the algorithm has been correctly matched to a hit-pattern template.

Confronting the prevalent issue of data with missing detector hits, the quantum template matching algorithm has been adapted and tested to mitigate the complexity of reconstructing tracks from imperfect data. By modifying the general oracle from Section 4, the quantum template matching algorithm has been used to correctly identify hit-pattern templates for a track traversing the detector with one detector layer failing to register a hit. This task is highly non-trivial for classical track-identification techniques. Remarkably, the quantum resources required, and the complexity of the circuit, do not increase for imperfect data, providing a quick and efficient method for identifying tracks from data with missing hits. Figure 5 demonstrates the quantum template matching algorithm's ability to successfully return possible hit-pattern templates for data with missing hits, with high probability.

The quantum methodologies presented in this article not only adeptly manage incomplete data but also underline the durability and adaptability of quantum algorithms when faced with real-world, inconsistent datasets. Furthermore, our exploration of track encoding and utilizing templates for various hit patterns in detectors provides deeper insights into the potential of quantum techniques in collider physics. These findings emphasize the immense promise of quantum computing in high-energy physics.

To conclude, while acknowledging the challenges inherent to charged track finding, our research underscores the pivotal role and promise of quantum algorithms in setting new benchmarks and advancing the task of charged-track finding in particle collision studies.

The raw data supporting the conclusions of this article will be made available by the authors, without undue reservation.

CB: Writing—original draft. MS: Writing—original draft. AT: Writing—original draft. SW: Writing—original draft. IX: Writing—original draft.