^{1}Department of Physics, Blackett Laboratory, Imperial College, London, United Kingdom^{2}Institute for Particle Physics Phenomenology, Department of Physics, Durham University, Durham, United Kingdom

In high-energy particle collisions, charged track finding is a complex yet crucial endeavor. We propose a quantum algorithm, specifically quantum template matching, to enhance the accuracy and efficiency of track finding. Abstracting the Quantum Amplitude Amplification routine by introducing a data register, and utilizing a novel oracle construction, allows data to be parsed to the circuit and matched with a hit-pattern template, without prior knowledge of the input data. Furthermore, we address the challenges posed by missing hit data, demonstrating the ability of the quantum template matching algorithm to successfully identify charged-particle tracks from hit patterns with missing hits. Our findings therefore propose quantum methodologies tailored for real-world applications and underline the potential of quantum computing in collider physics.

## 1 Introduction

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 $\mathcal{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.

## 2 Grover Search and Quantum Amplitude Amplification

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*_{1}, *x*_{2}, …, *x*_{N}} with one or more elements of interest, *m*_{j}, which can be encoded onto *n* = log_{2}(*N*) qubits as an equal superposition,

where ${\mathcal{A}}_{G}={H}^{\otimes 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*_{0} is a phase inversion on the zero state, and in the case of the Grover Search, ${\mathcal{A}}_{G}^{\u2020}={\mathcal{A}}_{G}$, 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 $\mathcal{Q}$ to achieve the highest probability of measuring a state of interest is

The Grover Search, therefore, scales as $\mathcal{O}(\sqrt{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 $\mathcal{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 $\mathcal{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.

### 2.1 Quantum Amplitude Amplification

The Grover algorithm performs a search on a uniform, unstructured database encoded onto *n*-qubits using a Hadamard transformation, ${\mathcal{A}}_{G}={H}^{\otimes n}$. However, it is often the case that it is not efficient to encode the database as a uniform superposition, but instead as an arbitrary state, |*s*′〉, prepared using the unitary operation $\mathcal{A}$. Quantum Amplitude Amplification (QAA; Brassard et al., 2002) is a generalization of the Grover Search algorithm which can perform a search on |*s*′〉 by modifying the Grover Iterator from Equation (3).

As shown in Equation (2), the amplification of a marked state is performed by reflecting around the state |*s*〉. Generalizing to an arbitrary initial state, the diffuser operation now reflects around the state |*s*′〉, and thus has the form ${D}^{\prime}=\mathcal{A}{S}_{0}{\mathcal{A}}^{\u2020}$. The Grover Iterator becomes,

such that the Grover Iterator from Equation (5) can be retrieved by identifying the preparation of the state |*s*〉 as an *n*-qubit Hadamard transform. Figure 1 shows a schematic circuit diagram for Quantum Amplitude Amplification.

**Figure 1**. Schematic circuit diagram for Quantum Amplitude Amplification (QAA) on *n* qubits. The circuit is initialized by preparing an arbitrary state using the unitary operation $\mathcal{A}$. The state is then parsed to the QAA routine which amplifies the amplitudes of interesting states in the initial state. The QAA routine is applied *t*-times to return an interesting state with high probability, upon measurement. The QAA routine is constructed from two operations: the oracle, which marks the interesting states by inverting their phase, and the diffuser, which performs a reflection to amplify the amplitudes of the marked states.

### 2.2 Oracle construction

The explicit form of the oracle, *S*_{f}, has so far remained an undefined black box in both the Grover and QAA routines. The only speculation is that the oracle must mark any interesting states within the database by inverting the phase of the marked states' amplitudes. Consider the example where a database of four states is encoded onto two qubits via a Hadamard transform,

It is possible to define an oracle which will search this database for the state |11〉 by applying a controlled-*Z* gate operation, which will apply the *Z*-gate operation to the target qubit if the control qubit is in the “1” state. The oracle operation therefore has the form

Acting the oracle on the initial state, we find

thus the state |11〉 has been marked by the oracle. However, if the target state now changes from |11〉, the form of the oracle has to change. For the problem of track finding, this is limiting as one would have to transpile the circuit each time a data string is retrieved from the detector to correctly search for, and identify, a matching hit-pattern template in the database. In Section 4, an algorithm is proposed that removes this limitation by generalizing the oracle construction, allowing for the same circuit to be used for all data retrieved from the detector, without having to know how to construct the oracle *a priori*.

## 3 Track finding via associative memory

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.

**Figure 2**. A single track through a 12-module detector, arranged in four layers of three detector modules. The red track shows the “true” track through the detector, with the blue circles representing the hits in the detector. The black tracks show a selection of possible tracks which can also lead to this hit pattern in the detector. Increasing the granularity of the detector decreases the number of tracks corresponding to a single hit pattern, but increases the combinatorial challenge of finding possible hit patterns left by charged particles.

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.

## 4 Quantum template matching for track finding

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, ${\stackrel{~}{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 ${\mathcal{A}}_{D}$. 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.^{1} The templates are encoded onto the template register as a linear superposition of all possible tracks through the unitary operation ${\mathcal{A}}_{T}$. The individual hit-pattern encodings are displayed in Table 1. The state preparation has the general form

**Table 1**. Full list of track templates for all possible hit-patterns in a 12 module detector, with the modules arranged in four layers of three modules.

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, ${\stackrel{~}{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*_{0}. 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, ${\stackrel{~}{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 $\mathcal{A}={\mathcal{A}}_{T}$. 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.

**Figure 3**. Schematic circuit diagram for the quantum template matching algorithm for charged track finding. The circuit comprises two registers, the data register, |*d*〉, and the template register, |*t*〉. The state preparation step encodes hit data from the detector onto the data register, and the database of hit-pattern templates onto the template register using the unitary operations ${\mathcal{A}}_{D}$ and ${\mathcal{A}}_{T}$, respectively. The Quantum Amplitude Amplification (QAA) routine is then applied *t*-times to correctly identify the hit pattern within the database, with high probability. The general oracle marks the state in the template database which corresponds to the hit pattern from the detector, encoded on the data register. The diffuser operator then amplifies the marked amplitudes. A measurement is then performed to return the matched template.

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 ${\mathcal{A}}_{D}$, 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^{4} shots on the qasm_simulator without a noise model.^{2} The results are displayed in Figure 4, showing that the correct match is achieved with high probability, >90% efficiency.

**Figure 4**. Results from the quantum template matching algorithm for two detector-hit data scenarios. **(A, B)** Show the correct identification of Tracks 1 and 5 from Table 1, shown in the top right-hand corner of the plots. The algorithm successfully identifies the correct hit-pattern templates from the database with high probability, >90%. The algorithm requires three iterations of the QAA routine, and has been run on the qasm_simulator for 10^{4} shots on the device.

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 ${\stackrel{~}{S}}_{f}$, the quantum template matching algorithm can identify possible tracks in imperfect data, a highly non-trivial task for current classical techniques.

## 5 Track finding on data with missing hits

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, ${\stackrel{~}{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 ${\stackrel{~}{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, ${\stackrel{~}{S}}_{f}^{\prime}$, follows the same form as ${\stackrel{~}{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*_{0}. 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 ${\stackrel{~}{S}}_{f}^{\prime}$ therefore has the same effect as the oracle ${\stackrel{~}{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, ${\stackrel{~}{S}}_{f}^{\prime}$, 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.^{3} Figure 5 shows the results from 10^{4} 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.

**Figure 5**. Results from the quantum template matching algorithm with the modified oracle for data with a missing hit in the third detector layer. The results show the correct identification of the two possible hit patterns, Tracks 8 and 9 from Table 1. The algorithm successfully identifies the correct high-pattern templates with high probability, >80%. The algorithm requires two iterations of the QAA routine, and has been run on qasm_simulator for 10^{4} shots on the device.

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, ${\stackrel{~}{S}}_{f}^{\prime}$, 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.

## 6 Conclusion

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^{4} 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.

## Data availability statement

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

## Author contributions

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

## Funding

The author(s) declare that no financial support was received for the research, authorship, and/or publication of this article.

## Acknowledgments

We thank Patrick Dunne, Wayne Luk, Mikael Mieskolainen, Mathieu Pellen, Zhiqiang Que, and Andy Rose for valuable discussions. We acknowledge the use of IBM Quantum Services for this work and to advanced services provided by the IBM Quantum Researchers Program.

## Conflict of interest

The authors declare that the research was conducted in the absence of any commercial or financial relationships that could be construed as a potential conflict of interest.

## Publisher's note

All claims expressed in this article are solely those of the authors and do not necessarily represent those of their affiliated organizations, or those of the publisher, the editors and the reviewers. Any product that may be evaluated in this article, or claim that may be made by its manufacturer, is not guaranteed or endorsed by the publisher.

## Author disclaimer

The views expressed are those of the authors, and do not reflect the official policy or position of IBM or the IBM Quantum Team.

## Footnotes

1. ^The choice of one-hot encoding has been made to allow for the algorithm to deal well with perfect and imperfect data from the detector, as will be outlined in Section 5. Other choices of encoding may prove to be more optimal, for example encoding each track in the computational basis.

2. ^The qasm_simulator is a 32-qubit quantum simulator that simulates a fully fault-tolerant quantum device, without noise effects.

3. ^In practice, Quantum Counting (Brassard et al., 1998) can be used to determine the number of interesting states, *m*.

## References

Aad, G., Abad, E., Abdallah, J., Abdelalim, A. A., Abdesselam, A., Abdinov, O., et al. (2008). The ATLAS experiment at the CERN large Hadron Collider. *JINST* 3:S08003. doi: 10.1088/1748-0221/3/08/S08003

Araz, J. Y., and Spannowsky, M. (2022). Classical versus quantum: comparing tensor-network-based quantum circuits on Large Hadron Collider data. *Phys. Rev. A* 106:e062423. doi: 10.48550/arXiv.2202.10471

Bapst, F., Bhimji, W., Calafiura, P., Gray, H., Lavrijsen, W., and Linder, L. (2020). A pattern recognition algorithm for quantum annealers. *Comput. Softw. Big Sci.* 4:1. doi: 10.48550/arXiv.1902.08324

Barata, J. A., Du, X., Li, M., Qian, W., and Salgado, C. A. (2023). Quantum simulation of in-medium QCD jets: momentum broadening, gluon production, and entropy growth. *Phys. Rev. D* 108:e056023. doi: 10.1103/PhysRevD.108.056023

Bardi, A., Belforte, S., Berryhill, J., Cerri, A., Clark, A. G., Culbertson, R., et al. (1998). SVT: an online silicon vertex tracker for the CDF upgrade. *Nucl. Instrum. Meth. A* 409, 658–661.

Bauer, C. W., de Jong, W. A., Nachman, B., and Provasoli, D. (2021). Quantum algorithm for high energy physics simulations. *Phys. Rev. Lett.* 126:e062001. doi: 10.48550/arXiv.1904.03196

Bepari, K., Malik, S., Spannowsky, M., and Williams, S. (2021). Towards a quantum computing algorithm for helicity amplitudes and parton showers. *Phys. Rev. D* 103:e076020. doi: 10.48550/arXiv.2010.00046

Bepari, K., Malik, S., Spannowsky, M., and Williams, S. (2022). Quantum walk approach to simulating parton showers. *Phys. Rev. D* 106:e056002. doi: 10.1103/PhysRevD.106.056002

Blance, A., and Spannowsky, M. (2020). Unsupervised event classification with graphs on classical and photonic quantum computers. *JHEP* 21:170. doi: 10.48550/arXiv.2103.03897

Brassard, G., Hoyer, P., Mosca, M., and Tapp, A. (2002). Quantum amplitude amplification and estimation. *Contemp. Math.* 305, 53–74. doi: 10.1090/conm/305/05215

Brassard, G., Høyer, P., and Tapp, A. (1998). “Quantum counting,” in *Automata, Languages and Programming: 25th International Colloquium, ICALP'98 Aalborg, Denmark, July 13–17, 1998 Proceedings 25* (Springer), 820–831.

Bunkowski, K. (2019). The algorithm of the CMS level-1 overlap muon track finder trigger. *Nucl. Instr. Methods Phys. Res. Sect. A* 936, 368–369. doi: 10.1016/j.nima.2018.10.173

Butz, E. (2018). Operation and Performance of the CMS outer tracker. *PoS Vertex* 2017:e013. doi: 10.22323/1.309.0013

Cerati, G. (2015). Vertexing and Tracking Algoritms at High Pile-Up. *PoS Vertex* 2014:e037. doi: 10.22323/1.227.0037

Chatrchyan, S., Hmayakyan, G., Khachatryan, V., Sirunyan, A. M., Adolphi, R., Anagnostou, G., et al. (2008). The CMS experiment at the CERN LHC. *JINST* 3:S08004. doi: 10.1088/1748-0221/3/08/S08004

Chatrchyan, S., Khachatryan, V., Sirunyan, A. M., Tumasyan, A., Adam, W., Bergauer, T., et al. (2014). Description and performance of track and primary-vertex reconstruction with the CMS tracker. *JINST* 9:P10009. doi: 10.1088/1748-0221/9/10/P10009

Chawdhry, H. A., and Pellen, M. (2023). Quantum simulation of colour in perturbative quantum chromodynamics. *arXiv 2303.04818*. doi: 10.48550/arXiv.2303.04818

Ciavarella, A., Klco, N., and Savage, M. J. (2021). Trailhead for quantum simulation of SU(3) Yang-Mills lattice gauge theory in the local multiplet basis. *Phys. Rev. D* 103:e094501. doi: 10.1103/PhysRevD.103.094501

Collaboration, T. A. (2021). The atlas fast tracker system. *J. Instrument*. 16:P07006. doi: 10.48550/arXiv.2101.05078

Davoudi, Z., Shaw, A. F., and Stryker, J. R. (2022). General quantum algorithms for Hamiltonian simulation with applications to a non-Abelian lattice gauge theory. *arXiv 2212.14030*. doi: 10.48550/arXiv.2212.14030

Dell'Orso, M., and Ristori, L. (1989). VLSI structures for track finding. *Nucl. Instrum. Meth. A* 278, 436–440.

Duckett, P., Facini, G., Jastrzebski, M., Malik, S., Scanlon, T., and Rettie, S. (2022). Reconstructing charged particle track segments with a quantum-enhanced support vector machine. *arXiv 2212.07279*. doi: 10.48550/arXiv.2212.07279

Fromm, M., Philipsen, O., Spannowsky, M., and Winterowd, C. (2023). Simulating ℤ_{2} Lattice Gauge theory with the variational quantum thermalizer. *arXiv 2306.06057.* doi: 10.48550/arXiv.2306.06057

Gao, S., Hayes, F., Croke, S., Messenger, C., and Veitch, J. (2022). Quantum algorithm for gravitational-wave matched filtering. *Phys. Rev. Res*. 4:e023006. doi: 10.1103/PhysRevResearch.4.023006

Giovannetti, V., Lloyd, S., and Maccone, L. (2008). Quantum random access memory. *Phys. Rev. Lett*. 100:160501. doi: 10.48550/arXiv.0708.1879

Gray, H. M., and Terashi, K. (2022). Quantum computing applications in future colliders. *Front. Phys*. 10:864823. doi: 10.3389/fphy.2022.864823

Grover, L. K. (1996). A fast quantum mechanical algorithm for database search. *arXiv quant-ph/9605043*. doi: 10.48550/arXiv.quant-ph/9605043

Grover, L. K. (1997). Quantum mechanics helps in searching for a needle in a haystack. *Phys. Rev. Lett*. 79, 325–328.

Gustafson, G., Prestel, S., Spannowsky, M., and Williams, S. (2022). Collider events on a quantum computer. *JHEP* 11:e035. doi: 10.48550/arXiv.2207.10694

Jordan, S. P., Lee, K. S. M., and Preskill, J. (2014). Quantum algorithms for fermionic quantum field theories. *arXiv 1404.7115*. doi: 10.48550/arXiv.1404.7115

Kan, A., and Nam, Y. (2021). Lattice quantum chromodynamics and electrodynamics on a universal quantum computer. *arXiv 2107.12769*. doi: 10.48550/arXiv.2107.12769

Kane, C., Grabowska, D. M., Nachman, B., and Bauer, C. W. (2022). Efficient quantum implementation of 2+1 U(1) lattice gauge theories with Gauss law constraints. *arXiv 2211.10497*. doi: 10.48550/arXiv.2211.10497

Li, T., Guo, X., Lai, W. K., Liu, X., Wang, E., Xing, H., et al. (2022). Partonic collinear structure by quantum computing. *Phys. Rev. D* 105:L111502. doi: 10.48550/arXiv.2106.03865

Mott, A., Job, J., Vlimant, J. R., Lidar, D., and Spiropulu, M. (2017). Solving a Higgs optimization problem with quantum annealing for machine learning. *Nature* 550, 375–379. doi: 10.1038/nature24047

Nicolaidou, R., Chevalier, L., Hassani, S., Laporte, J. F., Menedeu, E. L., and Ouraou, A. (2010). Muon identification procedure for the atlas detector at the lhc using muonboy reconstruction package and tests of its performance using cosmic rays and single beam data. *J. Phys*. 219:e032052. doi: 10.1088/1742-6596/219/3/032052

Paulson, D., Dellantonio, L., Haase, J. F., Celi, A., Kan, A., Jena, A., et al. (2021). Simulating 2D effects in lattice gauge theories on a quantum computer. *PRX Quant*. 2:e030334. doi: 10.48550/arXiv.2008.09252

Plesch, M., and Brukner, I. C. V. (2011). Quantum-state preparation with universal gate decompositions. *Phys. Rev. A* 83:e032302. doi: 10.1103/PhysRevA.83.032302

Qiskit Contributors (2023). *Qiskit: An Open-Source Framework for Quantum Computing*. Available online at: https://docs.quantum.ibm.com/support

Rosenthal, G. (2023). *Query and Depth Upper Bounds for Quantum Unitaries via Grover Search*. Available online at: https://arxiv.org/abs/2111.07992

Shapoval, I., and Calafiura, P. (2019). Quantum associative memory in hep track pattern recognition. *EPJ Web Conf* . 214:e01012. doi: 10.48550/arXiv.1902.00498

Shende, V., Bullock, S., and Markov, I. (2006). Synthesis of quantum-logic circuits. *IEEE Trans. Comput. Aided Design Integr. Circ. Syst*. 25, 1000–1010. doi: 10.1109/TCAD.2005.855930

Sun, X., Tian, G., Yang, S., Yuan, P., and Zhang, S. (2023). Asymptotically optimal circuit depth for quantum state preparation and general unitary synthesis. *IEEE Trans. Comput. Aided Design Integr. Circ. Syst*. 42, 3301–3314. doi: 10.1109/TCAD.2023.3244885

Ventura, D., and Martinez, T. (2000). Quantum associative memory. *Inform. Sci*. 124, 273–296. doi: 10.1016/S0020-0255(99)00101-2

Wu, S. L., Chan, J., Guan, W., Sun, S., Wang, A., Zhou, C., et al. (2021). Application of quantum machine learning using the quantum variational classifier method to high energy physics analysis at the LHC on IBM quantum computer simulator and hardware with 10 qubits. *J. Phys. G* 48:125003. doi: 10.1088/1361-6471/ac1391

Zhang, X.-M., Li, T., and Yuan, X. (2022). Quantum state preparation with optimal circuit depth: implementations and applications. *Phys. Rev. Lett*. 129:230504. doi: 10.1103/PhysRevLett.129.230504

Zhang, X. M., Yung, M. H., and Yuan, X. (2021). Low-depth quantum state preparation. *Phys. Rev. Res*. 3:e043200. doi: 10.1103/PhysRevResearch.3.043200

Keywords: quantum computing, track reconstruction, collider physics, collider phenomenology, Quantum Amplitude Amplification

Citation: Brown C, Spannowsky M, Tapper A, Williams S and Xiotidis I (2024) Quantum pathways for charged track finding in high-energy collisions. *Front. Artif. Intell.* 7:1339785. doi: 10.3389/frai.2024.1339785

Received: 16 November 2023; Accepted: 07 May 2024;

Published: 30 May 2024.

Edited by:

Seung-Hwan Lim, Oak Ridge National Laboratory (DOE), United StatesReviewed by:

Andrea Delgado, Oak Ridge National Laboratory (DOE), United StatesYutaro Iiyama, The University of Tokyo, Japan

Copyright © 2024 Brown, Spannowsky, Tapper, Williams and Xiotidis. This is an open-access article distributed under the terms of the Creative Commons Attribution License (CC BY). The use, distribution or reproduction in other forums is permitted, provided the original author(s) and the copyright owner(s) are credited and that the original publication in this journal is cited, in accordance with accepted academic practice. No use, distribution or reproduction is permitted which does not comply with these terms.

*Correspondence: Simon Williams, simon.j.williams@durham.ac.uk