WorksPhysics and Astronomy
Efficient Iterative Symmetrization algorithm for quantum computing and hadron applications
Abstract
Efficient algorithms for the (anti)symmetrization of quantum registers are necessary for upcoming few- and many-body physics applications, from atomic to particle-physics scales. We propose a recursive algorithm (anti)symmetrizing the last particle added to memory, each time one is created or destroyed, respect to the rest of already (anti)symmetrized ones. Given a generalized Dicke state (GDS) of quantum registers, each assigned to a particle, the algorithm produces another GDS of registers (of qubits each) using a mere and single-qubit gates, and clean auxiliary qubits. The (anti)symmetrizing operator constructed for this purpose depends on the quantum numbers of the additional particle being introduced or ``created''. The algorithm improves upon the construction presented in Appendix A of \cite{Galvez-Viruet:2024hry} by almost two powers of and is on par with the most efficient methods to date, while ideally suited for dynamical memory management with variable particle number. We exemplify its applicability with a small selection of problems from hadron physics which are expected to be addressable with upcoming quantum computers.
Introduction
Statement of the problem
A cornerstone of Quantum Mechanics is the symmetrization / antisymmetrization of wavefunctions upon exchanging integer / half-integer quanta. This is crucial in the atomic Aufbau, the nuclear shell model, the quark model, and any field theory lifted from them such as Quantum Chromodynamics, to properly count physical states and their energy spectrum.
With the dawn of the quantum-computer era approaching, the simulation of quantum systems is likely to be revolutionized. But in multiparticle and field theory simulations, the high expenditure of fully (anti)symmetrizing identical quanta, with possible permutations, can easily run out of control and needs to be tamed by appropriate algorithms.
Part of us [1] have developed an (anti)symmetrization algorithm which we have applied to interesting physics problems in hadron physics which would much profit from a full-scale quantum computer (see § 4 for some examples). Because main parts of this algorithm seem to have been rediscovered by further researchers [2], and because in deploying it we have seen certain improvements which can be effected, we here wish to reappraise it.
In a quantum-register representation, one divides the quantum memory into registers of size each. At any time in the computation, of them will contain one of possible orthogonal quantum states or “modes” . The rest are empty registers, storing a default state , which we denote as . (In quark-hadron physics each occupied register can be thought of as a quark or a gluon, in nuclear physics as a nucleon, etc.)
If each of the modes has occupation number (0 or 1 for fermions but any number of bosons), where , the total number of occupied registers is . The fully symmetric state of the occupied registers is then
where is the set of permutations of indices. The objective of the symmetrization algorithm is the implementation of an operator which, provided the -th register stores the mode and the previous registers are already symmetric, extends the symmetry to the newly written mode
where is a symmetric state of occupied registers. Thus (note the inverse order in the productorial),
Similar definitions can be written for step-antisymmetrizers , which extend the antisymmetry from to occupied registers. As particle repetition makes their implementation substantially harder, we dedicate much of the article to the development of step-symmetrizers , and for the antisymmetrizers only quote substantial differences when needed. The bulk of this article (§ 2 and § 3) are dedicated to its detailed construction.
Extant (anti)symmetrization algorithms
Quantum algorithms for imposing exchange symmetry in first-quantized encodings differ in their admissible inputs, treatment of repeated occupations, and resource objectives. Several first-quantized state-preparation algorithms construct an antisymmetric state from a strictly ordered list of occupied modes with in an -dimensional single-particle space through the transformation
Restricting the input to ordered configurations ensures that distinct inputs produce orthogonal output states, allowing a unitary implementation on the specified input subspace. An early efficient implementation prepares a superposition of permutation labels and uses reversible sorting and unsorting to rearrange the particle registers, with the fermionic sign determined by permutation parity. Its reported complexity is elementary operations [3]. This construction shows that preparing a superposition of configurations does not require factorial computational resources (unlike Full Configuration Interaction methods in Quantum Chemistry or Nuclear Physics). A subsequent state-preparation framework also incorporates conversion from second- to first-quantized representations [4].
A later sorting-based construction generates permutation records by reversibly sorting auxiliary random labels and then applies the corresponding permutations to the particle registers [5]. Any “collisions” among the auxiliary labels are detected and removed in a post-selection step, while permutation parity supplies the fermionic sign. Asymptotically optimal sorting networks use comparators, whereas odd-even mergesort networks require , giving gate complexity. As in [3], the algorithm coherently acts on superpositions of strictly ordered configurations. To work with bosons, however, it is not sufficient to omit the permutation signs, however, since repeated labels (modes with occupancy ) may appear.
The necessary extension is explicitly addressed by algorithms that allow non-strictly increasing input lists [6]. The normalized bosonic goal state has the form given in Eq. (1). When labels are repeated, different permutations can produce the same particle configuration while leaving distinguishable records in the auxiliary registers. These redundant records must therefore be coherently erased.
Starting from ordered list with possible repetitions, the resulting algorithms achieve depth with ancillary qubits for a single classical input list, with high success probability, and depth with ancillaries for arbitrary coherent superpositions, with unit success probability [6].
To compare these reported counts with our new algorithm is difficult. We have to take into account that the depth of those quantum circuits, defined as the number of consecutive layers of gates which cannot be parallelized, is generally smaller than their total gate count. Therefore, the depth estimates reported for them in the literature should not be directly compared with the gate complexity of the iterative symmetrization algorithm presented here. Unfortunately, a more detailed gate-level decomposition of the algorithm in [6] would be necessary to establish a meaningful comparison1. From cursory examination, we think it is safe to state that our algorithm is at least as efficient as the best known methods.
A complementary approach builds exchange symmetry recursively, incorporating one particle at a time into an already symmetric or antisymmetric state. This is the crux of our earlier algorithm [1]. We introduced step-symmetrizers and step-antisymmetrizers as part of a particle-register implementation of creation and annihilation operators, and described unitary implementations of these transformations [1]. In particular, the step-antisymmetrizer has the form
where swaps particle registers and , and the added orbital is orthogonal to those previously occupied (think, for example, of momentum modes).
A recently reported recursive construction [2] assumes access to preparation circuits , with , for mutually orthogonal orbitals. Its auxiliary registers are subsequently uncomputed using the inverse preparation circuits and orbital orthogonality. No numerical ordering of the orbitals is required. For computational-basis orbitals, the reported -gate count scales as . For nontrivial orbitals, the preparation adopted in [2] gives scaling, with an additional dirty ancillaries. A measurement-and-feed-forward variant retains unit success probability and approximately halves, on average, the number of orbital-preparation and inverse-preparation operations that dominate the cost in this regime.
These approaches therefore address different versions of the state-preparation problem. Sorting-based methods provide favorable particle-number scaling for ordered configurations, general bosonic symmetrization requires explicit treatment of repeated occupations, and recursive fermionic constructions incorporate independently specified orbital-preparation circuits.
We are now ready to present the novel improvement which we here propose to our earlier setup. In summary, we present a novel UDD algorithm which improves our earlier implementation by almost a factor of by using the Shukla-Vedula algorithm [7] to prepare uniform superpositions, and improving the final steps in appendix § 7.§ 2.a of [1] to prepare register .
Modification of our earlier step-symmetrization algorithm
In our earlier algorithm [1], the implementation of the (unitary) step symmetrizer unnecessarily increased the asymptotic costs for large particle number, mostly due to the use of the LL (“Locate the Largest”) algorithm and the expensive UDD subroutine to which we dedicate the next subsection 2.1. We here revisit its implementation as well as that of the step (anti)symmetrizers, in subsection 2.2, to later demonstrate a gain in asymptotic costs.
UDD subroutine
The UDD “uniform digit decomposition” algorithm (SDD in [1]) is a key subroutine in the implementation of the step symmetrizes that disentangles the auxiliary registers needed to account for mode multiplicities greater than 1. It consists on the decomposition of a binary number of Hamming weight (number of nonvanishing bits ) [8] into its binary digits in superposition. The result of the decomposition is stored in an auxiliary register initially in the reference state ,
where has digits. The state should be understood as having qubit (counting from right to left and starting at 1) in state and all the others in state . Denoting by the set of indices for which and denoting the th of such indices, i.e. we have
(In the sum runs over kets, not over bits inside the same ket as in The algorithm is explained by providing the evolution of an ancillary state through several steps and substeps . We will omit which remains unentangled, until step 6. These instructions should be programmed in the order given:
The decomposition register has qubits. We introduce further auxiliary registers with qubits and with qubits. Throughout the algorithm, denotes the th qubit of register (and likewise for the other registers), counting from right to left and starting at 1. A ket containing all those ancillary registers is
Calculate and store it in register ,
Note that a binary number of length contains at most ones. Since the number of ones can range from to , there are possible values of . This step would only require register to have qubits. The reason it instead allocated qubits is for later usage in step 6. For , we have that , so only in this particular case, register must have qubits and not one.
Costs: This preparation can be achieved with unit adders on qubits of , which gives a total cost of single-qubit and CNOT gates and extra auxiliary qubits.
Unless , apply the following transformation to register ,
to do this, use the Shukla-Vedula algorithm [7] to prepare uniform superpositions (substituting the generic of that algorithm by the variable here needed). The algorithm starts with the value of encoded in register and as is unknown outside, unlike in the original Shukla-Vedula formulation [7], one proceeds with a series of single-controlled rotations, Hadamard gates and CNOTs. Its reported asymptotic cost is of order gates. In our case, the values of different from zero are stored in a quantum register of qubits, therefore their single-controls should be transformed into multi-controlled gates over qubits, with an asymptotic cost of gates and auxiliary qubits.
The total cost, since there are possible values of , is gates and auxiliary qubits.
Loop over from to ,
4.1 If register is and qubit is in state , apply an X gate to the corresponding qubit . Such an X gate, controlled by qubits, has a cost of single-qubit and CNOT gates.
4.2 If decrease register by modulo . Note that a unit decrease of then gives , and therefore it is necessary to perform unit decreases to go a complete cycle and return to a given initial value. This controlled decrease, operating on the qubits of , then entails costs of single-qubit and CNOT gates.
End the loop by adding modulo to register . The result is
The remaining steps will basically handle the “uncomputation” (reversing of the operations effected) of registers and to get the clean result on .
Costs: The addition on registers of size qubits require single-qubit and CNOT gates.
Uncompute register . This takes in Eq. (11) to a in which it is set to , free for recycling, with no other change.
The following three steps disentangle registers from . Register is in a superposition of states with only one qubit in state . This qubit coincides with a qubit such that the number of qubits with is equal to the state of . For each from 1 to , the first step initiates qubits to if qubit , the second step then compares qubits and , with from 1 to and for each coincidence diminishes the value of by 1. A final step disentangles register :
6.1 First, if initiate qubit to . Now, iterate from to . If or the qubit , then also initiate qubit . This gives,
Costs: OR tests over a constant number of qubits cost single qubit gates and CNOT.
6.2 For each from 1 to such that , the state of is equal to how many qubits are 1 with , furthermore, register has qubits to equal to . We can therefore disentangle by subtracting 1 each time two qubits of and with the same index are both ,
Costs: subtraction circuits on qubits controlled over a constant number of qubits cost single-qubit gates and CNOT and extra auxiliary qubits.
6.3 Finally, repeating 6.1 in reverse to disentangle gives,
Registers and are now disentangled and can be ignored; the state of is exactly the right hand side of Eq. (7) which then closes the algorithm, its validity and efficacy having been demonstrated.
Total costs: Examining all steps, we find that the algorithm requires gates and auxiliary qubits, a substantial improvement with respect to the complexity reported in [1].
Step-(anti)symmetrizer implementation
We now revisit the implementation of the step symmetrizer already discussed in appendix A.2.b of [1] providing a more detailed proof of the asymptotic costs. Substantial differences with respect to the implementation of step-antisymmetrizers are pointed out.
We now incorporate the main particle register to the auxiliary ones discussed in the previous Subsection 2.1. Proceeding in alphabetic order, the input particle registers are collectively denoted by , and we refer to the th one as subregister . In addition to , we introduce two auxiliary qubit registers, (which will keep track of repeatedly occupied boson modes) and , each consisting of qubits, where is the number of occupied registers.2 The implementation of of Eq. (2) proceeds as follows.
The first step is then to initialize register in the state and, provided mode lies in the last occupied subregister , initialize register in the state (this is so there is exactly a 1 in each term of the linear superposition, with the rest of the qubits being set to zero). If this is so,
(In the antisymmetrization case, each particle configuration must be unique, and therefore mode exclusively sits on register by hypothesis3. This renders register unnecessary. The preparation of register proceeds in the same way.)
To execute the transformation of Eq. (15) we apply single-qubit gates controlled by the qubits of a single subregister of , which entails costs of CNOT and single-qubit gates and auxiliary registers.
This step is only necessary for the symmetrization case, and absent for fermions. Register consists of sub-registers of size storing different particle modes. We use an auxiliary register to mark the sub-registers which contain mode , so ( will correspond to whereas to ). In this way, instead of having to work with sub-registers of qubits, we work with a single register of qubits. This is done by applying one multi-controlled gate controlled on each subregister , and with target qubit , for to ; see Figure 1.
Figure 1. Multicontrolled operation to store the positions of the mode in register . Qubit is flipped to when sub-register stores mode . Notation: the denotes conditioning on the multi-qubits state rather than in a single qubit state .
Provided that previously occupied particle registers are maintained to be fully symmetrized at all times, and that mode sits on register , the auxiliary registers will be transformed into (up to normalization),
the notation means that qubits have rotated to state , with the remaining, omitted indices indicate qubits which remain unchanged. is the multiplicity of mode for register 1 to .
Costs: single-qubit gates and auxiliary qubits.
Symmetrize the -th register with all the others by applying the operator
where the permutator interchanges qubits and of register and interchanges particle registers and of . This construction guarantees unitarity. After its application, the auxiliary registers are (we drop normalization constants and the superindex from the permutators),
If , or , the permutator interchanges two qubits of whose states are (and two particle registers with mode ) and no change is produced. Therefore Eq. (18) can be rewritten as:
and the second line encompasses the remaining terms. Focusing on those, the interchange entails a new qubit in state 1 from positions 1 to (and a 0 in position ). For the case in which :
applying the change , to the last two summands of Eq. (20),
and the second line of Eq. (19) now reads,
Repeating the same transformation for each of the indices we have
so that
Now, realizing that the first line of corresponds to the case in which we have,
The permutations of the indices ensure that the particle registers are fully symmetrized, so all that remains is to disentangle the auxiliary registers. Note that no further controls are needed to prevent unwanted executions when mode does not lie in register , since in this case registers and wouldn’t be initialized.
In the anti-symmetrization case, the first term in the operator Eq. (17) should be changed to include a sign whenever and there is no need for the permutator over register . At the end of this step, the content of register will be interchanged for the content of all the other registers, thus achieving antisymmetrization. The last step is then to disentangle register .
Costs: Same for symmetrizers and antisymmetrizers, register has qubits, each of which is used as control over two-particle register SWAP gates that costs Toffoli gates and extra auxiliary qubits. Since each Toffoli can be decomposed into a constant number of single-qubit gates and CNOTs, the total cost is single-qubit and CNOT gates and extra auxiliary qubits.
This step is only needed for the symmetrization case. Since registers and are exactly of the form generated by the UDD algorithm, that is
register can be disentangled by applying the UDD algorithm in reverse:
Costs: gates and extra auxiliary qubits.
For the (anti)symmetrization case, disentangle register by undoing step 2, that is, for to apply a multi-controlled , with the controls being the qubits of subregister and the target being the qubit.
Costs: single-qubit gates and auxiliary qubits.
Summing up all costs, the total asymptotic complexity for symmetrization is gates and auxiliary qubits and for antisymmetrization is gates and auxiliary qubits.
Worked examples of the step symmetrization and UDD algorithms
Step-symmetrizers
As an example, let us see how to symmetrize a state with three bosons. The goal of the operator is to construct the symmetric state of three particles. In this example, we consider three registers and two different modes, and , with the mode appearing twice. We assume that registers 1 and 2 are already symmetrized
We want to add register 3, which contains the known mode . Thus, the initial state (stored in register ) is
where we use the notation . Following Eq. (15), to keep track of all indices we introduce two auxiliary registers and , each containing three qubits, initialized as
So that
Register is used to mark the positions containing the known mode . For this, a gate, controlled by subregister , is applied to each qubit . The gate flips whenever contains the mode . This operation can be understood as a . Therefore,
which gives
Now, we apply the operator of Eq. (17) with $j=3
where the permutation exchanges particle registers 3 and , while does the same for the auxiliary register . Specifically, depending on the state of register , the permutation operators applied act as follows,
Therefore, the first component leaves the state invariant, the second exchanges registers 3 and 2, and the third exchanges registers 3 and 1. Applying these permutations, we obtain
Equation (39) has the structure generated by the UDD operator. As an example, subsection 3.2 demonstrates that the UDD generates the state corresponding to the first line of Eq. (39) from the state , therefore disentangling register if applied in reverse,
and similarly for the and configurations. Thus,
Finally, we can repeat the marking operation to return to its initial state
Thus, the auxiliary registers are decoupled, and the particle registers contain the symmetric state of the three particles.
UDD
Now, we illustrate how the UDD algorithm described in § 2.1 works. We consider three qubits, with the register initialized in the state . Thus, the Hamming weight is , and the occupied positions are and .
To implement the algorithm, we introduce two auxiliary registers, and , with and qubits, respectively. In our case, , so both have 2 qubits.
As explained in § 2.1, in the second step, register is used to store the Hamming weight of , which is the number of qubits in the state. Since , equals 2 and therefore, rotates to ,
In the third step, we prepare a superposition of the possible values of the counter (for this we need as an input). In this case, it is sufficient to apply a Hadamard gate to the first qubit of , obtaining
In the fourth step, we loop over the qubits of , from to . At each position, if and , we apply a gate to . Next, if , we subtract one from the counter , with modulo 4. Omitting the registers and , which remain invariant, we start from
For , as , no operation is needed. For , we have . In the first term, , so is activated. In the second term, , so remains unchanged. After subtracting one from , we obtain
For , we also have . Now, the counter is zero in the second term, so is activated, while remains unchanged in the first term. After subtracting one from , we have
Finally, we add to , recovering its initial value,
In the fifth step, we undo the operations used in the second step to calculate the Hamming weight in , returning to its initial state. However, is entangled with , so we have to apply the sixth step to decouple it.
In step 6.1 we use the marked position in to activate the corresponding qubits of . To do this we use a cascade algorithm, we first activate if and then activate if or . In the first term, , so we have . Therefore is activated, giving . In the second term, so is activated first and followed by , giving . Therefore, we obtain
In step 6.2, we subtract one from for each position where . The first term remains invariant, while the second term has one subtracted, since . Thus, both terms have ,
Finally, in step 6.3, we reverse the operations of step 6.1 to return to its initial state,
Thus, the auxiliary registers and are finally decoupled and ready for reuse, while contains a uniform superposition of the digits in , as desired.
Problems amenable to deployment of the algorithm
The Complutense algorithm presented in this work is needed wherever the particle-register encoding [1] is used, because (anti)symmetrization enters the definition of creation and annihilation operators, and hence of every Hamiltonian written in second quantization. In this section we first recall how these operators are built and why this makes the algorithm (or a substitute thereof) necessary for any problem formulated in second quantization. We then discuss two applications that we have already studied in this encoding: the fragmentation of jets into hadrons [9] and the equation of state of neutron stars [10].
Second quantization in the particle-register encoding
Any discretized problem formulated in second quantization can be written in the particle-register encoding. To see why all of them require a symmetrization algorithm, recall how the encoding works.
The quantum memory is divided into registers of qubits, each able to store a particle via a presence qubit, in if the register is empty or if it is occupied, and qubits encoding the mode of the particle. Therefore, if we want to create a particle in a quantum memory with a single register, we must activate the presence qubit and write the corresponding mode in the remaining qubits,
where are control operators acting on the presence qubit,4 , and are the set and scrap operators, which write the quantum numbers of mode into the selected register.
The operator acts on the empty register as
whereas on an occupied register it returns zero, since .
Multiple registers will be occupied in order, starting from the rightmost one. Thus, the field-theoretical creation (annihilation) operator is represented by the sum of such auxiliary operators acting on each register; any term that attempts to write a particle in an already occupied register (annihilate in an empty one) or that breaks the filling pattern, vanishes through the use of projectors. Thus, only the contribution of the operator acting on the appropriate register survives.
Finally, getting to the core discussion of this article, the correct statistics must be taken into account. If we create (annihilate) bosons, the corresponding symmetrizations must be effected, whereas for fermions we must antisymmetrize. Here our method shines because, if the memory on which the creation operator acts already has the proper symmetrization, only the target register where a new particle is written has to be (anti)symmetrized with the already occupied ones.
Therefore, for bosons, the creation operator is given by
where the superscript denotes a memory of registers, is an identity on of them, and is the projector onto states of an -register memory with registers to occupied and the rest empty. To account for boson enhancement, the operator projects on memories in which exactly out of the occupied registers store mode ; and the corresponding state is therefore multiplied by . For fermions, the unitary step-symmetrizer is replaced by the unitary step-antisymmetrizer , and the sum over collapses to the case , which enforces the Pauli exclusion principle.
Note that Eq. (53) is the sum of operators acting on different registers. In each of them, the filling pattern is enforced by , which checks that there are no empty registers to the right of the -th register, and , which verifies that there are no occupied ones to the left. Thus, if these requirements are met, what remains is the creation of the particle in the -th register via the single-register operator of Eq. (51), followed by its symmetrization with the particles already stored through .
Notice that because of these projectors and , the step-symmetrizer is only applied to configurations with active registers where in the -th register the mode has just been stored. In this way, any other configuration makes the state be annihilated before the symmetrization.
As we have seen, symmetrization is a fundamental step in the creation (annihilation) of particles, but it also enters every operation performed on the memory. For example, state preparation and every step of time evolution contain (anti)symmetrizations.
Practical applications
We now present a brief reminder of current problems of interest in hadron physics where lattice gauge theory struggles to provide first-principle results and quantum computing would be of much use. Therein our (anti)symmetrization method will find ample use when coding in a particle-register basis. We shall keep this discussion short and refer the reader to a review on the topic [11].
Jet fragmentation into hadrons
Fragmentation functions require evaluating quark/gluon matrix elements taken on two different points in light-front time, so the states have to be evolved, with all semiinclusive identified hadron states contributing. Such computation escapes the possibilities of lattice gauge theory, but it would not be particularly difficult on a quantum computer. We in light-front QCD [9] and others [13] in the Nambu-Jona-Lasinio model have already explored the possibility of predicting fragmentation functions from first principles, see Figure 2. (Quantum computers can also be useful in the extraction of the fragmentation functions from data [14].) With few quanta one can escape (anti)symmetrization, but as more particles intervene, the necessity to properly (anti)symmetrize (quarks) gluons becomes apparent.

Figure 2. Evaluation of charm quark to fragmentation function (data points) with an algorithm amenable for a quantum computer, compared to previous NRQCD computations (various lines). T: total QCD light-front Hamiltonian included. V: calculation where only the “V” potential terms are included [12].
In practical terms: when computing structure or fragmentation functions, our encoding is more efficient than Jordan-Wigner at high and intermediate or , the longitudinal momentum fractions. At extremely low , in the saturation regime where the number of particles approaches the number of quantum modes, the present particle-register encoding becomes subcompetitive respect to the Jordan-Wigner one (but can be used anyway if computational resources permit, there is no fundamental roadblock).
Many other applications in hadron structure, such as the computation of form factors and, more generically, the hadron tensor, are possible [15], although for several of them lattice gauge theory is making strides [16].
Neutron star equation of state
The equation of state of neutron star cores is out of reach of lattice QCD because of the sign problem at finite chemical potential. In Ref. [10] we showed that one first principles point at , three times more precise than the present band, would reduce the uncertainty on the radius of a star from 36% to 15%. We then minimized the energy of Weyl-gauge QCD cells with a VQE with three quarks plus one gluon, or one quark plus two gluons.
Under the qubit limit of the simulations, Ref. [10] implemented calculation for two ansatzs:
A color singlet superposition of three quarks with zero or one gluon ().
A color-triplet superposition of one quark with up to two gluons ().
As explained in § 4.1, particles are (anti)symmetrized in the moment they are created. The states should be antisymmetric under the interchange of quarks in the register, which is prepared creating particles one by one and iteratively antisymmetrizing them, whereas the states should be symmetric under the exchange of the two gluons.
The effect of these (anti)symmetrizers helps us to reduce the parameters of the VQE. If we want the variational method to give a reliable result, the trial states must be as general as possible while containing the minimum number of parameters for the program to converge. We must propose states that will not be annihilated by the particle register encoding due to incorrect symmetry in order not to waste parameters as well as introducing additional physical constraints. Moreover, keeping the registers properly ordered and symmetrized simplifies measuring the Hamiltonian and squared Gauss-law operator, , cutting the number of Pauli terms of interaction terms of two gluons from to .
Overall, these three to four particle simulations already produce physical EoS curves and sound speeds, proving that the calculation works end to end. Scaling up to realistic cells (six or more quarks plus gluons, needing qubits) will require, apart of more powerful quantum computers, (anti)symmetrizing many more particles, making the improved algorithm directly relevant.
String-breaking and hadron production for Monte Carlo simulated showers
A classical problem of high-energy physics is to compute the hadron showers produced from a collision among partons, and see which hadron species and with what momenta are produced, to calibrate experiment and eventually to test underlying theory [17]. However, the Monte Carlo programs which simulate these showers are based on classical simulations. Thus, when quantum effects become important, such as in baryon correlations where antisymmetry blocks part of the phase space, disagreement with experiment can become apparent [18]. While patches exist [19], a full quantum treatment of particle production from the QCD Hamiltonian will probably have to be addressed one day. We see no way of realistically attempting this than simulating the string-breaking process with a quantum computer [20].
Outlook
The resource analysis in § 2 distinguishes bosonic symmetrization from fermionic antisymmetrization. Sequential preparation scales quadratically in particle number up to logarithmic factors, with a contribution linear in the register width. The bosonic implementation additionally requires UDD to disentangle auxiliary records associated with repeated occupations, whereas the fermionic specialization avoids this step. This full-preparation scaling should be distinguished from the cost of inserting one mode into an already symmetrized state, which is smaller.
Compared with [3], our bounds replace the quadratic register-width dependence by a linear contribution, together with particle-number-dependent overheads. The sorting-based construction in [5] achieves more favorable particle-number scaling for global preparation of distinct-mode configurations. Our distinguishing features are incremental insertion and explicit treatment of repeated bosonic occupations. Comparisons with [4] must additionally separate orbital loading and identification from exchange-symmetrization costs.
The appropriate comparison with [2] is our fermionic specialization, which does not require UDD. The -count reported and our elementary-gate count use different resource metrics. The nontrivial-state estimates include preparation costs absent from our basis-mode insertion problem. For repeated bosonic occupations, [6] instead prioritizes low-depth global preparation, including coherent superpositions of input lists. Our method therefore provides an efficient incremental primitive without implying a general resource advantage over global preparation algorithms. A more detailed gate-level decompositions of the sorting algorithms would be necessary to establish a meaningful comparison between the two approaches.
These computational considerations also motivate the potential applications to hadronic physics discussed below.
Given that this communication has been invited at a conference on the Physics of Excited Nucleons, we should quickly recapitulate how the computational methods here discussed might be of use in this subfield. In essence, we would deploy this work, given a powerful enough quantum computer, to predict observables there where Lattice methods may fall short.
Very excited spectrum: since exponentially suppressed signals have to be reconstructed from the raw numerical data, a variational approach based on a quantum computer may be an interesting complementary approach, perhaps along the lines of our earlier work [21] but with extensive variational bases and with the QCD Hamiltonian instead of a Cornell model. We do have an encoding of in the Weyl gauge at hand, as already discussed.
In high-energy production amplitudes and fragmentation, the Minkowski-based light-front approach on a quantum computer would become the go-to method if it could be deployed on a full quantum computer. This is probably the most direct and impactful application.
For hadron structure functions, Lattice methods have been devised [22] that give access to certain aspects of parton distribution functions, but quantum computing could also make a contribution here and offer checks with different systematics.
The difficulties of working at finite density suggest the usage of quantum computers for nuclear matter computations and in neutron stars.
Acknowledgments
We acknowledge partial support from grants PID2025-170350NB-I00 and PID2025-169724NB-C21, FPU21/04180, FPU24/00948 and FPU25/00872 of the spanish government’s program MICIU/AEI/10.13039/501100011033 and of ERDF/EU; and from the Horizon Europe programme (Grant Agreement No. 101292522, HADRON-2030).
Unit Adders and Unit Subtractors: implementation
The goal of the second step of the UDD Algorithm (§ 2.1) is to evaluate the total number of 1s in a computational basis state stored in a quantum register of qubits. To store this count, the algorithm requires an auxiliary register of qubits initialized to . This is achieved via Algorithm 1.
Algorithm 1 Step 2 of the UDD Algorithm (§ 2.1)
Require: Register in basis state , auxiliary register in state Ensure: Total number of 1s in stored in register
for to do
Apply unit adder to if
end for
return Register
Expressed in terms of its constituent bits, with , the required operation of the unit adder is the following:
If (adds it to register )
If (it does nothing)
That is, if , the integer stored in is incremented by 1 modulo ; otherwise, the identity operation is performed. This means that the unit adder needs to control that is in state for it to act over register . The only thing left to explain is how the addition itself is implemented in .
Decomposing the state of register into its individual bits , when adding 1 to a binary number, a bit only changes if all of the bits to its right are 1:
Bit always changes.
Bit changes only if .
Bit changes only if and .
Bit changes only if , , , .
To do this on our quantum circuit, we note the following: if we modified first, we would destroy the carry information needed to determine whether and should change. Therefore, the circuit is applied from highest to lowest weight (and, as we said before, conditioning each gate on the input bit ). The resulting implementation is shown in Figure 3a.

Figure 3. Quantum circuits for the controlled unit arithmetic operations: (a) unit adder, and (b) unit subtractor.
The unit subtractor performs the inverse operation of the unit adder:
Because this operation is the exact inverse, it is implemented by executing the sequence of gates of the unit adder in reverse order (starting from the least significant bit up to the most significant bit ), as depicted in Figure 3b. This implementation is simple but costly in terms of gate executions, requiring single-qubit gates and CNOTs. More efficient algorithms achieve linear scaling, see [23].
References
- [1]J. J. Gálvez-Viruet and F. J. Llanes-Estrada, Phys. Rev. D 110 (2024), 116018 doi:10.1103/PhysRevD.110.116018 [arXiv:2406.03147 [hep-th]].
- [2]E. Rule, I. A. Chernyshev, I. Stetcu, J. Carlson and R. Weiss, Quantum 10 (2026), 2056 doi:10.22331/q-2026-04-08-2056DOI
- [3]D. S. Abrams and S. Lloyd, Phys. Rev. Lett. 79 (1997), 2586-2589 doi:10.1103/PhysRevLett.79.2586 [arXiv:quant-ph/9703054 [quant-ph]].DOI
- [4]N. J. Ward, I. Kassal and A. Aspuru-Guzik, J. Chem. Phys. 130 (2009) no.19, 194105 doi:10.1063/1.3115177 [arXiv:0812.2681 [quant-ph]].DOI
- [5]D. W. Berry, M. Kieferová, A. Scherer, Y. R. Sanders, G. H. Low, N. Wiebe, C. Gidney and R. Babbush, npj Quantum Inf. 4 (2018), 22 doi:10.1038/s41534-018-0071-5 [arXiv:1711.10460 [quant-ph]].DOI
- [6]Z. Liu, A. M. Childs and D. Gottesman, Phys. Rev. X 16 (2026) no.3, 031056 doi:10.1103/9qhy-ms2y [arXiv:2411.04019 [quant-ph]].DOI
- [7]A. Shukla and P. Vedula, Quant. Inf. Proc. 23 (2024), 38 doi:10.1007/s11128-024-04258-4 [arXiv:2306.11747 [quant-ph]].DOI
- [8]R. W. Hamming, Bell Syst. Tech. J. 29 147-160, 1950.
- [9]J. J. Gálvez-Viruet, F. J. Llanes-Estrada, N. M. de Arenaza, M. Gómez-Rocha and T. J. Hobbs, Phys. Rev. D 114, 054021 (2026) doi:10.1103/4grj-x7xv [arXiv:2510.18869 [hep-ph]].
- [10]A. Castaño-García, N. J. Dios-Bilbao, J. J. Gálvez-Viruet, F. J. Llanes-Estrada, M. Logrosán-Álvarez, N. M. Arenaza and M. Gómez-Rocha, [arXiv:2608.06515 [hep-ph]].
- [11]J. J. Gálvez-Viruet, F. J. Llanes-Estrada and M. Gómez-Rocha, Int. J. Mod. Phys. A 41 (2026), 2630003 doi:10.1142/S0217751X26300036 [arXiv:2510.26293 [hep-ph]].
- [12]J. J. Gálvez-Viruet, F. J. Llanes-Estrada, N. M. Arenaza, M. Gómez-Rocha and T. J. Hobbs, Proceedings of the 14th Edition of the LHC Physics Conference, PoS(LHCP2026)093 [arXiv:2608.30375 [hep-ph]].
- [13]T. Li, H. Xing and D. B. Zhang, [arXiv:2406.05683 [hep-ph]].arxiv.org/abs/2406.05683
- [14]D. F. Rentería-Estrada, R. J. Hernández-Pinto, G. Rodrigo, R. Sassot and G. F. R. Sborlini, [arXiv:2609.20557 [hep-ph]].
- [15]D. Zou et al. [QuNu], Phys. Rev. D 114 (2026), 076001 doi:10.1103/sdvz-1ltn [arXiv:2606.17003 [hep-ph]].DOI
- [16]H. W. Lin, W. Wang and Y. Zhao, Prog. Part. Nucl. Phys. 152 (2027), 104274 doi:10.1016/j.ppnp.2026.104274DOI
- [17]T. Sjöstrand, S. Ask, J. R. Christiansen, R. Corke, N. Desai, P. Ilten, S. Mrenna, S. Prestel, C. O. Rasmussen and P. Z. Skands, Comput. Phys. Commun. 191 (2015), 159-177 doi:10.1016/j.cpc.2015.01.024DOI
- [18]Ł. K. Graczykowski and M. A. Janik, Phys. Rev. C 104 (2021) no.5, 054909 doi:10.1103/PhysRevC.104.054909 [arXiv:2108.00678 [nucl-th]].DOI
- [19]N. Demazure, V. G. Sebastián and F. J. Llanes-Estrada, Few Body Syst. 64 (2023), 57 doi:10.1007/s00601-023-01838-5DOI
- [20]C. W. Bauer, A. N. Ciavarella, J. C. Halimeh, Y. Meurice, S. Mrenna, M. J. Savage, G. Cataldi, H. Froland, D. M. Grabowska and S. Grieninger, et al. [arXiv:2611.00214 [hep-ph]].arxiv.org/abs/2611.00214
- [21]N. M. de Arenaza, J. J. Gálvez-Viruet and F. J. Llanes-Estrada, Eur. Phys. J. A 60 (2024), 216 doi:10.1140/epja/s10050-024-01430-3DOI
- [22]A. NielMiera, K. Ebira, W. Good and H. W. Lin, [arXiv:2610.31597 [hep-lat]].
- [23]C. Gidney, Quantum 2 (2018), 74 doi:10.22331/q-2018-06-18-74 [arXiv:1709.06648 [quant-ph]].DOI
