betaFeedback

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 (j−1)(j-1) quantum registers, each assigned to a particle, the algorithm produces another GDS of jj registers (of nqbn_{qb} qubits each) using a mere O(jlog⁡22j+jnqb)\mathcal{O}(j\log_2^2 j + j n_{qb}) CNOT\mathtt{CNOT} and single-qubit gates, and 3j+⌈log⁡2j⌉+O(max⁡(nqb,log⁡2j))3j+\lceil\log_2j\rceil+\mathcal{O}(\max(n_{qb},\log_2 j)) 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 jj 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 jj identical quanta, with j!j! 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 nn registers of size nqbn_{qb} each. At any time in the computation, j−1j-1 of them will contain one of τ\tau possible orthogonal quantum states or “modes” α1,α2…ατ\alpha_1, \alpha_2 \ldots\alpha_\tau. The rest are empty registers, storing a default state ∣0⊗nqb⟩\lvert0^{\otimes n_{qb}}\rangle, which we denote as ∣Ω⟩\lvert\Omega\rangle. (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 nμn_\mu (0 or 1 for fermions but any number of bosons), where μ∈{1,…,τ}\mu\in\{1,\ldots,\tau\}, the total number of occupied registers is j−1=∑μnμj-1=\sum_\mu n_\mu. The fully symmetric state of the j−1j-1 occupied registers is then

∣(αj−1,⋯ ,α1)S⟩≡1(j−1)!∏μnμ!∑σ∈π[j−1]∣ασ(j−1)⟩⊗⋯⊗∣ασ(1)⟩(1)\lvert(\alpha_{j-1},\cdots,\alpha_1)_{S}\rangle\equiv\frac{1}{\sqrt{(j-1)!\prod_\mu n_\mu!}}\sum_{\sigma\in\pi[j-1]}\lvert\alpha_{\sigma(j-1)}\rangle\otimes\cdots\otimes\lvert\alpha_{\sigma(1)}\rangle \tag*{(1)}

where π[j−1]\pi[j-1] is the set of permutations of j−1j-1 indices. The objective of the symmetrization algorithm is the implementation of an operator Sj†(β)S_j^\dagger(\beta) which, provided the jj-th register stores the mode β\beta and the previous j−1j-1 registers are already symmetric, extends the symmetry to the newly written mode β\beta

Sj†(β)∣β⟩j⊗∣(Φj−1)S⟩=∣(β,Φj−1)S⟩(2)S_j^\dagger(\beta)\lvert\beta\rangle_j\otimes\lvert(\Phi_{j-1})_S\rangle=\lvert(\beta,\Phi_{j-1})_S\rangle \tag*{(2)}

where ∣(Φj−1)S⟩\lvert(\Phi_{j-1})_S\rangle is a symmetric state of j−1j-1 occupied registers. Thus (note the inverse order in the productorial),

∣(αj,⋯ ,α1)S⟩=∏k=j1Sk†(αk)∣αj,αj−1,⋯ ,α1⟩.(3)\lvert(\alpha_j,\cdots,\alpha_1)_S\rangle=\prod_{k=j}^{1}S_k^\dagger(\alpha_k)\lvert\alpha_j,\alpha_{j-1},\cdots,\alpha_1\rangle. \tag*{(3)}

Similar definitions can be written for step-antisymmetrizers Aj†(β)A_j^\dagger(\beta), which extend the antisymmetry from j−1j-1 to jj occupied registers. As particle repetition makes their implementation substantially harder, we dedicate much of the article to the development of step-symmetrizers Sj†(β)S_j^\dagger(\beta), 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 r1<⋯<rnr_1 < \cdots< r_n in an MM-dimensional single-particle space through the transformation

∣r1,…,rn⟩⟼∣Ψ−(r)⟩=1n!∑π∈Snsgn⁡(π)∣rπ(1),…,rπ(n)⟩.(4)\lvert r_1,\ldots,r_n\rangle\longmapsto\lvert\Psi^{-}(r)\rangle= \frac{1}{\sqrt{n!}}\sum_{\pi\in S_n}\operatorname{sgn}(\pi)\lvert r_{\pi(1)},\ldots,r_{\pi(n)}\rangle. \tag*{(4)}

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 O(n2log⁡2M)O(n^2\log^2 M) elementary operations [3]. This construction shows that preparing a superposition of n!n! 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 O(nlog⁡n)O(n\log n) comparators, whereas odd-even mergesort networks require O(nlog⁡2n)O(n\log^2 n), giving O(nlog⁡2nlog⁡M)O(n\log^2 n\log M) 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 n(q)>1n(q)>1) 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 O(log⁡nlog⁡log⁡n)O(\log n\log\log n) depth with O(nlog⁡n+log⁡M)O(n\log n+\log M) ancillary qubits for a single classical input list, with high success probability, and O(log⁡3nlog⁡log⁡n)O(\log^3 n\log\log n) depth with O(nlog⁡n)O(n\log n) 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

Ak=1k(I−∑j=1k−1Pjk),(5)\mathcal{A}_k = \frac{1}{\sqrt{k}}\left(I-\sum_{j=1}^{k-1}\mathcal{P}_{jk}\right), \tag*{(5)}

where Pjk\mathcal{P}_{jk} swaps particle registers jj and kk, 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 Uj∣0⟩⊗q=∣ϕj⟩U_j\lvert0\rangle^{\otimes q}=\lvert\phi_j\rangle, with q=⌈log⁡2M⌉q=\lceil\log_2 M\rceil, for mutually orthogonal orbitals. Its auxiliary registers are subsequently uncomputed using the inverse preparation circuits Uj†U_j^\dagger and orbital orthogonality. No numerical ordering of the orbitals is required. For computational-basis orbitals, the reported TT-gate count scales as O(n2log⁡M)O(n^2\log M). For nontrivial orbitals, the preparation adopted in [2] gives O(n2M)O(n^2\sqrt{M}) scaling, with an additional O(M)O(\sqrt{M}) 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 j2j^2 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 CC.

Modification of our earlier step-symmetrization algorithm

In our earlier algorithm [1], the implementation of the (unitary) step symmetrizer Sj†(α)S_j^{\dagger}(\alpha) 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 bb of Hamming weight kk (number of nonvanishing bits k=∑i=1nbik = \sum_{i=1}^{n} b_i) [8] into its binary digits bib_i in superposition. The result of the decomposition is stored in an auxiliary register CC initially in the reference state ∣0⟩C\lvert0\rangle_C,

UDD⁡∣0⟩C∣b⟩B={1k(∑i=1nbi∣2i−1⟩C)∣b⟩B,k>0,∣0⟩C∣b⟩Bk=0,(6)\operatorname{UDD}\lvert0\rangle_C\lvert b\rangle_B = \begin{cases} \frac{1}{\sqrt{k}}\left(\sum_{i=1}^{n} b_i\lvert2^{i-1}\rangle_C\right)\lvert b\rangle_B, & k > 0,\\ \lvert0\rangle_C\lvert b\rangle_B & k = 0, \end{cases} \tag*{(6)}

where b=∑i=1nbi2i−1b = \sum_{i=1}^{n} b_i2^{i-1} has nn digits. The state ∣2i−1⟩\lvert2^{i-1}\rangle should be understood as having qubit ii (counting from right to left and starting at 1) in state ∣1⟩\lvert1\rangle and all the others in state ∣0⟩\lvert0\rangle. Denoting by ll the set of indices ii for which bi=1b_i = 1 and denoting ljl_j the jjth of such indices, i.e. l={i∣bi=1}={l1,l2,…,lk}l = \{i|b_i = 1\} = \{l_1,l_2,\ldots,l_k\} we have

(∑i=1nbi∣2i−1⟩C)⊗(∑j=1nbj2j−1)B=(∑i=1k∣2li−1⟩C)⊗(∑j=1k2lj−1)B.(7)\left(\sum_{i=1}^{n} b_i\lvert2^{i-1}\rangle_C\right)\otimes\left(\sum_{j=1}^{n} b_j2^{j-1}\right)_B = \left(\sum_{i=1}^{k}\lvert2^{l_i-1}\rangle_C\right)\otimes\left(\sum_{j=1}^{k}2^{l_j-1}\right)_B. \tag*{(7)}

(In ∣ ⟩C\lvert\ \rangle_C the sum runs over kets, not over bits inside the same ket as in ∣ ⟩B.)\lvert\ \rangle_B.) The algorithm is explained by providing the evolution of an ancillary state through several steps and substeps ∣ψ1⟩→∣ψ2⟩→…∣ψ6,3⟩\lvert\psi_1\rangle\rightarrow\lvert\psi_2\rangle\rightarrow\ldots\lvert\psi_{6,3}\rangle. We will omit ∣ ⟩B\lvert\ \rangle_B which remains unentangled, until step 6. These instructions should be programmed in the order given:

  1. The decomposition register CC has nn qubits. We introduce further auxiliary registers EE with max⁡(n−1,⌈log⁡2(n+1)⌉)\max(n-1,\lceil\log_2(n+1)\rceil) qubits and DD with ⌈log⁡2n⌉\lceil\log_2 n\rceil qubits. Throughout the algorithm, CiC_i denotes the iith qubit of register CC (and likewise for the other registers), counting from right to left and starting at 1. A ket containing all those ancillary registers is

∣ψ1⟩=∣0⟩E∣0⟩D∣0⟩C.(8)\lvert\psi_1\rangle= \lvert0\rangle_E\lvert0\rangle_D\lvert0\rangle_C. \tag*{(8)}
  1. Calculate k=∑ibik = \sum_i b_i and store it in register EE,

∣ψ2⟩=∣k⟩E∣0⟩D∣0⟩C.(9)\lvert\psi_2\rangle= \lvert k\rangle_E\lvert0\rangle_D\lvert0\rangle_C. \tag*{(9)}

Note that a binary number of length nn contains at most nn ones. Since the number of ones can range from 00 to nn, there are n+1n+1 possible values of kk. This step would only require register EE to have ⌈log⁡2(n+1)⌉\lceil\log_2(n+1)\rceil qubits. The reason it instead allocated n−1n-1 qubits is for later usage in step 6. For n=2n=2, we have that n−1<⌈log⁡2(n+1)⌉n-1<\lceil\log_2(n+1)\rceil, so only in this particular case, register EE must have ⌈log⁡23⌉=2\lceil\log_2 3\rceil=2 qubits and not one.

Costs: This preparation can be achieved with O(n)O(n) unit adders on O(log⁡2n)O(\log_2 n) qubits of EE, which gives a total cost of O(nlog⁡2n)O(n\log_2 n) single-qubit and CNOT gates and O(log⁡2(n))O(\log_2(n)) extra auxiliary qubits.

  1. Unless k=0k=0, apply the following transformation to register DD,

∣ψ2⟩=∣k⟩E∣0⟩D∣0⟩C→∣ψ3⟩=∣k⟩E(1k∑i=0k−1∣i⟩D)∣0⟩C.(10)|\psi_2\rangle=|k\rangle_E|0\rangle_D|0\rangle_C\to|\psi_3\rangle=|k\rangle_E\left(\frac{1}{\sqrt{k}}\sum_{i=0}^{k-1}|i\rangle_D\right)|0\rangle_C. \tag*{(10)}

to do this, use the Shukla-Vedula algorithm [7] to prepare uniform superpositions (substituting the generic MM of that algorithm by the variable kk here needed). The algorithm starts with the value of kk encoded in register ∣k⟩E|k\rangle_E and as kk is unknown outside, unlike in the original Shukla-Vedula formulation [7], one proceeds with a series of single-controlled RYR_Y rotations, Hadamard gates and CNOTs. Its reported asymptotic cost is of order O(log⁡2k)O(\log_2 k) gates. In our case, the values of kk different from zero are stored in a quantum register of log⁡2n\log_2 n qubits, therefore their single-controls should be transformed into multi-controlled gates over log⁡2n+1\log_2 n+1 qubits, with an asymptotic cost of O(log⁡2nlog⁡2k)O(\log_2 n\log_2 k) gates and O(log⁡2n)O(\log_2 n) auxiliary qubits.

The total cost, since there are nn possible values of k>0k>0, is O(nlog⁡22n)O(n\log_2^2 n) gates and O(log⁡2n)O(\log_2 n) auxiliary qubits.

  1. Loop over ii from i=1i=1 to i=ni=n,

4.1 If register DD is ∣0⟩D=∣0⋯0⟩|0\rangle_D=|0\cdots0\rangle and qubit BiB_i is in state ∣1⟩|1\rangle, apply an X gate to the corresponding qubit CiC_i. Such an X gate, controlled by log⁡2n\log_2 n qubits, has a cost of O(log⁡2n)O(\log_2 n) single-qubit and CNOT gates.

4.2 If bi=1b_i=1 decrease register DD by 11 modulo 2⌈log⁡2n⌉=2nD2^{\lceil\log_2 n\rceil}=2^{n_D}. Note that a unit decrease of ∣0⟩D|0\rangle_D then gives ∣2nD−1⟩D|2^{n_D}-1\rangle_D, and therefore it is necessary to perform 2nD2^{n_D} unit decreases to go a complete cycle and return to a given initial value. This controlled decrease, operating on the O(log⁡2n)O(\log_2 n) qubits of ∣ ⟩D|\,\rangle_D, then entails costs of O(log⁡2n)O(\log_2 n) single-qubit and CNOT gates.

End the loop by adding ∣k⟩E|k\rangle_E modulo 2⌈log⁡2n⌉2^{\lceil\log_2 n\rceil} to register DD. The result is

∣ψ4⟩=∣k⟩E1k(∑j=1k∣j−1⟩D∣2lj−1⟩C).(11)|\psi_4\rangle=|k\rangle_E\frac{1}{\sqrt{k}}\left(\sum_{j=1}^{k}|j-1\rangle_D|2^{l_j-1}\rangle_C\right). \tag*{(11)}

The remaining steps will basically handle the “uncomputation” (reversing of the operations effected) of registers EE and DD to get the clean result on CC.

Costs: The addition on registers of size O(log⁡2n)O(\log_2 n) qubits require O(log⁡2n)O(\log_2 n) single-qubit and CNOT gates.

  1. Uncompute register EE. This takes ∣k⟩E|k\rangle_E in Eq. (11) to a ∣ψ5⟩|\psi_5\rangle in which it is set to ∣0⟩E|0\rangle_E, free for recycling, with no other change.

  1. The following three steps disentangle registers DD from CC. Register CC is in a superposition of states with only one qubit in state ∣1⟩|1\rangle. This qubit coincides with a qubit Bm=∣1⟩B_m=|1\rangle such that the number of qubits Bi=∣1⟩B_i=|1\rangle with i<mi<m is equal to the state of DD. For each ii from 1 to n−1n-1, the first step initiates qubits E1E_1 to EiE_i if qubit Ci+1=∣1⟩C_{i+1}=|1\rangle, the second step then compares qubits EjE_j and BjB_j, with jj from 1 to n−1n-1 and for each coincidence diminishes the value of DD by 1. A final step disentangles register EE:

6.1 First, if Cn=∣1⟩C_n=|1\rangle initiate qubit En−1E_{n-1} to ∣1⟩|1\rangle. Now, iterate from i=1i=1 to i=n−2i=n-2. If En−i=∣1⟩E_{n-i}=|1\rangle or the qubit Cn−i=∣1⟩C_{n-i}=|1\rangle, then also initiate qubit En−1−iE_{n-1-i}. This gives,

∣ψ6,1⟩=1k(∑i=1k∣2i−1−1⟩E∣i−1⟩D∣2i−1⟩C)∣∑j=1k2j−1⟩B.(12)|\psi_{6,1}\rangle= \frac{1}{\sqrt{k}}\left(\sum_{i=1}^{k}|2^{i-1}-1\rangle_E|i-1\rangle_D|2^{i-1}\rangle_C\right)\left|\sum_{j=1}^{k}2^{j-1}\right\rangle_B . \tag*{(12)}

Costs: O(n)O(n) OR tests over a constant number of qubits cost O(n)O(n) single qubit gates and CNOT.

6.2 For each mm from 1 to nn such that Cm=∣1⟩C_m=|1\rangle, the state of DD is equal to how many qubits BiB_i are 1 with i<mi<m, furthermore, register EE has qubits E1E_1 to Em−1E_{m-1} equal to ∣1⟩|1\rangle. We can therefore disentangle DD by subtracting 1 each time two qubits of BB and EE with the same index are both ∣1⟩|1\rangle,

∣ψ6,2⟩=1k(∑i=1k∣2i−1−1⟩E∣0⟩D∣2i−1⟩C)∣∑j=1k2j−1⟩B,(13)|\psi_{6,2}\rangle= \frac{1}{\sqrt{k}}\left(\sum_{i=1}^{k}|2^{i-1}-1\rangle_E|0\rangle_D|2^{i-1}\rangle_C\right)\left|\sum_{j=1}^{k}2^{j-1}\right\rangle_B, \tag*{(13)}

Costs: O(n)O(n) subtraction circuits on O(log⁡2n)O(\log_2 n) qubits controlled over a constant number of qubits cost O(nlog⁡2n)O(n\log_2 n) single-qubit gates and CNOT and O(log⁡2n)O(\log_2 n) extra auxiliary qubits.

6.3 Finally, repeating 6.1 in reverse to disentangle EE gives,

∣ψ6,3⟩=∣0⟩E∣0⟩D1k(∑i=1k∣2i−1⟩C)∣∑j=1k2j−1⟩B.(14)|\psi_{6,3}\rangle= |0\rangle_E|0\rangle_D\frac{1}{\sqrt{k}}\left(\sum_{i=1}^{k}|2^{i-1}\rangle_C\right)\left|\sum_{j=1}^{k}2^{j-1}\right\rangle_B . \tag*{(14)}

Registers DD and EE are now disentangled and can be ignored; the state of ∣ ⟩C⊗∣ ⟩B|\ \rangle_C\otimes|\ \rangle_B 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 O(nlog⁡22n)O(n\log_2^2 n) gates and j+⌈log⁡2j⌉+O(log⁡2n)j+\lceil\log_2 j\rceil+O(\log_2 n) auxiliary qubits, a substantial improvement with respect to the O(n3log⁡n)O(n^3\log n) 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 AA, and we refer to the iith one as subregister AiA_i. In addition to AA, we introduce two auxiliary qubit registers, BB (which will keep track of repeatedly occupied boson modes) and CC, each consisting of jj qubits, where jj is the number of occupied registers.2 The implementation of Sj(α)S_j^{(\alpha)} of Eq. (2) proceeds as follows.

  1. The first step is then to initialize register BB in the state ∣0⟩B\lvert0\rangle_B and, provided mode α\alpha lies in the last occupied subregister AjA_j, initialize register CC in the state 1j∑k=1j∣2k−1⟩C\frac{1}{\sqrt{j}}\sum_{k=1}^{j}\lvert2^{k-1}\rangle_C (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,

∣ϕ1⟩=1j∑k=1j∣2k−1⟩C⊗∣0⟩B⊗∣α,(Φj−1)S⟩A.(15)\lvert\phi_1\rangle=\frac{1}{\sqrt{j}}\sum_{k=1}^{j}\lvert2^{k-1}\rangle_C\otimes\lvert0\rangle_B\otimes\lvert\alpha,(\Phi_{j-1})_S\rangle_A . \tag*{(15)}

(In the antisymmetrization case, each particle configuration must be unique, and therefore mode α\alpha exclusively sits on register jj by hypothesis3. This renders register BB unnecessary. The preparation of register CC proceeds in the same way.)

To execute the transformation of Eq. (15) we apply O(j)\mathcal{O}(j) single-qubit gates controlled by the O(nqb)\mathcal{O}(n_{\mathrm{qb}}) qubits of a single subregister of AA, which entails costs of O(jnqb)\mathcal{O}(jn_{\mathrm{qb}}) CNOT and single-qubit gates and O(nqb)\mathcal{O}(n_{\mathrm{qb}}) auxiliary registers.

  1. This step is only necessary for the symmetrization case, and absent for fermions. Register AA consists of jj sub-registers of size nqbn_{\mathrm{qb}} storing different particle modes. We use an auxiliary register BB to mark the sub-registers AiA_i which contain mode α\alpha, so (Ai=∣α⟩A_i=\lvert\alpha\rangle will correspond to Bi=∣1⟩B_i=\lvert1\rangle whereas Ai≠∣α⟩A_i\ne\lvert\alpha\rangle to Bi=∣0⟩B_i=\lvert0\rangle). In this way, instead of having to work with jj sub-registers of nqbn_{\mathrm{qb}} qubits, we work with a single register BB of jj qubits. This is done by applying one multi-controlled gate CnqbX(α)C^{n_{\mathrm{qb}}}X(\alpha) controlled on each subregister AiA_i, and with target qubit BiB_i, for i=1i=1 to i=ji=j; see Figure 1.

Figure 1. Multicontrolled operation to store the positions of the α\alpha mode in register BB. Qubit BiB_i is flipped to ∣1⟩\lvert1\rangle when sub-register AiA_i stores mode ∣α⟩\lvert\alpha\rangle. Notation: the ∙α\bullet^\alpha denotes conditioning on the multi-qubits state ∣α⟩\lvert\alpha\rangle rather than in a single qubit state ∣1⟩\lvert1\rangle.

Provided that previously occupied particle registers are maintained to be fully symmetrized at all times, and that mode α\alpha sits on register jj, the auxiliary registers will be transformed into (up to normalization),

∣ϕ2⟩aux=∑k=1j∣2k−1⟩C⊗∑1≤l1<l2<⋯<ln1≤j−1∣(j,ln1,…,l2,l1)⟩B.(16)\lvert\phi_2\rangle_{\mathrm{aux}}=\sum_{k=1}^{j}\lvert2^{k-1}\rangle_C\otimes\sum_{1\le l_1<l_2<\cdots<l_{n_1}\le j-1}\lvert(j,l_{n_1},\ldots,l_2,l_1)\rangle_B . \tag*{(16)}

the notation means that qubits Bl1,⋯Bln1,BjB_{l_1}, \cdots B_{l_{n_1}}, B_j have rotated to state ∣1⟩\lvert1\rangle, with the remaining, omitted indices indicate qubits which remain unchanged. n1n_1 is the multiplicity of mode α\alpha for register 1 to j−1j-1.

Costs: O(jnqb)O(jn_{qb}) single-qubit gates and O(nqb)O(n_{qb}) auxiliary qubits.

  1. Symmetrize the jj-th register with all the others by applying the operator

Uperm≡∑k=1j∣2k−1⟩⟨2k−1∣C⊗Pj,kB⊗Pj,kA+(IC−∑k=1j∣2k−1⟩⟨2k−1∣C)⊗IB⊗IA(17)U_{\mathrm{perm}} \equiv\sum_{k=1}^{j} \lvert2^{k-1}\rangle\langle2^{k-1}\rvert_C \otimes P^B_{j,k} \otimes P^A_{j,k} + \left(I^C-\sum_{k=1}^{j}\lvert2^{k-1}\rangle\langle2^{k-1}\rvert_C\right)\otimes I^B\otimes I^A \tag*{(17)}

where the permutator Pl,kBP^B_{l,k} interchanges qubits ll and kk of register BB and Pl,kAP^A_{l,k} interchanges particle registers ll and kk of AA. This construction guarantees unitarity. After its application, the auxiliary registers are (we drop normalization constants and the superindex BB from the permutators),

∣ϕ3⟩aux=∑k=1j∣2k−1⟩C⊗∑1≤l1<l2<⋯<ln1≤j−1Pj,k(j,ln1,…,l2,l1)B.(18)|\phi_3\rangle_{\mathrm{aux}}=\sum_{k=1}^{j}|2^{k-1}\rangle_C\otimes\sum_{\substack{1\le l_1<l_2<\\\cdots<l_{n_1}\le j-1}}P_{j,k}(j,l_{n_1},\ldots,l_2,l_1)_B . \tag*{(18)}

If k=lik=l_i, i∈(1,…,n1)i\in(1,\ldots,n_1) or k=jk=j, the permutator interchanges two qubits of BB whose states are ∣1⟩|1\rangle (and two particle registers with mode α\alpha) and no change is produced. Therefore Eq. (18) can be rewritten as:

\begin{aligned} |\phi_3\rangle_{\mathrm{aux}}={}&\sum_{\substack{1\le l_1<l_2<\\\cdots<l_{n_1}\le j-1}}\left[\left(\sum_{m=1}^{n_1}|2^{l_m-1}\rangle_C+|2^{j-1}\rangle_C\right)\otimes(j,l_{n_1},\ldots,l_2,l_1)_B\\ &+\left(\sum_{\substack{k=1,\\k\notin(l_1,\ldots,l_{n_1})}}^{j-1}|2^{k-1}\rangle_C\otimes P_{j,k}(j,l_{n_1},\ldots,l_2,l_1)_B\right)\right]. \tag*{(19)} \end{aligned}

and the second line encompasses the remaining terms. Focusing on those, the interchange entails a new qubit in state 1 from positions 1 to j−1j-1 (and a 0 in position jj). For the case in which k∈(1,⋯ ,l1−1)k\in(1,\cdots,l_1-1):

∑1≤l1<l2<⋯<ln1≤j−1∑k=1,k∉(l1,…,ln1)j−1(⋯ )=∑1≤l1<l2<⋯<ln1≤j−1∑k=l1+1,k∉(l2,…,ln1)j−1(⋯ )+∑1<l1<l2<⋯<ln1≤j−1∑k=1l1−1(⋯ ),(20)\sum_{\substack{1\le l_1<l_2<\cdots<l_{n_1}\le j-1}}\sum_{\substack{k=1,\\k\notin(l_1,\ldots,l_{n_1})}}^{j-1}(\cdots) = \sum_{\substack{1\le l_1<l_2<\cdots<l_{n_1}\le j-1}}\sum_{\substack{k=l_1+1,\\k\notin(l_2,\ldots,l_{n_1})}}^{j-1}(\cdots) + \sum_{\substack{1<l_1<l_2<\cdots<l_{n_1}\le j-1}}\sum_{k=1}^{l_1-1}(\cdots), \tag*{(20)}

applying the change k→l1k\to l_1, li→li+1l_i\to l_{i+1} to the last two summands of Eq. (20),

∑1≤l1<l2<⋯<ln1≤j−1∑k=1,k∉(l1,…,ln1)j−1(⋯ )=∑1≤l1<l2<⋯<ln1≤j−1∑k=l1+1,k∉(l2,…,ln1)j−1(⋯ )+∑1≤l1<l2<⋯<ln1+1≤j−1(⋯ ),(21)\sum_{\substack{1\le l_1<l_2<\cdots<l_{n_1}\le j-1}}\sum_{\substack{k=1,\\k\notin(l_1,\ldots,l_{n_1})}}^{j-1}(\cdots) = \sum_{\substack{1\le l_1<l_2<\cdots<l_{n_1}\le j-1}}\sum_{\substack{k=l_1+1,\\k\notin(l_2,\ldots,l_{n_1})}}^{j-1}(\cdots) + \sum_{\substack{1\le l_1<l_2<\cdots<l_{n_1}+1\le j-1}}(\cdots), \tag*{(21)}

and the second line of Eq. (19) now reads,

∑1≤l1<l2<⋯<ln1≤j−1∑k=1,k∉(l1,…,ln1)j−1∣2k−1⟩C⊗Pj,k(j,ln1,…,l2,l1)B=∑1≤l1<l2<⋯ln1≤j−1∑k=l1+1,k∉(l2,…,ln1)j−1∣2k−1⟩C⊗Pj,k(j,ln1,…,l2,l1)B+∑1≤l1<l2<⋯ln1+1≤j−1∣2l1−1⟩C⊗∣(ln1+1,…,l2,l1)⟩B.(22)\begin{aligned} \sum_{\substack{1\le l_1<l_2<\cdots<l_{n_1}\le j-1}}\sum_{\substack{k=1,\\k\notin(l_1,\ldots,l_{n_1})}}^{j-1}|2^{k-1}\rangle_C\otimes P_{j,k}(j,l_{n_1},\ldots,l_2,l_1)_B \\ &=\sum_{\substack{1\le l_1<l_2<\cdots\\l_{n_1}\le j-1}}\sum_{\substack{k=l_1+1,\\k\notin(l_2,\ldots,l_{n_1})}}^{j-1}|2^{k-1}\rangle_C\otimes P_{j,k}(j,l_{n_1},\ldots,l_2,l_1)_B \\ &+ \sum_{\substack{1\le l_1<l_2<\cdots\\ l_{n_1+1}\le j-1}} |2^{l_1-1}\rangle_C \otimes|(l_{n_1+1},\ldots,l_2,l_1)\rangle_B. \tag*{(22)} \end{aligned}

Repeating the same transformation for each of the n1n_1 indices we have

∑1≤l1<l2<⋯<ln1≤j−1(∑k=1k∉(l1,…,ln1)j−1∣2k−1⟩C⊗Pj,k∣(j,ln1,…,l2,l1)⟩B)=∑1≤l1<l2<⋯<ln1+1≤j−1(∑m=1n1+1∣2lm−1⟩C)⊗∣(ln1+1,ln1,…,l2,l1)⟩B,(23)\begin{aligned} \sum_{\substack{1\le l_1<l_2<\\ \cdots<l_{n_1}\le j-1}} \left(\sum_{\substack{k=1\\ k\notin(l_1,\ldots,l_{n_1})}}^{j-1}|2^{k-1}\rangle_C\otimes P_{j,k}|(j,l_{n_1},\ldots,l_2,l_1)\rangle_B\right) \\ &= \sum_{\substack{1\le l_1<l_2<\\ \cdots<l_{n_1+1}\le j-1}} \left(\sum_{m=1}^{n_1+1}|2^{l_m-1}\rangle_C\right)\otimes|(l_{n_1+1},l_{n_1},\ldots,l_2,l_1)\rangle_B, \tag*{(23)} \end{aligned}

so that

∣ϕ3⟩aux=∑1≤l1<l2<⋯<ln1≤j−1(∑m=1n1∣2lm−1⟩C+∣2j−1⟩C)⊗∣(j,ln1,…,l2,l1)⟩B+∑1≤l1<l2<⋯<ln1+1≤j−1(∑m=1n1+1∣2lm−1⟩C)⊗∣(ln1+1,ln1,…,l2,l1)⟩B.(24)\begin{aligned} |\phi_3\rangle_{\mathrm{aux}} = \sum_{\substack{1\le l_1<l_2<\\ \cdots<l_{n_1}\le j-1}} \left(\sum_{m=1}^{n_1}|2^{l_m-1}\rangle_C+|2^{j-1}\rangle_C\right)\otimes|(j,l_{n_1},\ldots,l_2,l_1)\rangle_B \\ &+\sum_{\substack{1\le l_1<l_2<\\ \cdots<l_{n_1+1}\le j-1}} \left(\sum_{m=1}^{n_1+1}|2^{l_m-1}\rangle_C\right)\otimes|(l_{n_1+1},l_{n_1},\ldots,l_2,l_1)\rangle_B. \tag*{(24)} \end{aligned}

Now, realizing that the first line of ∣ϕ3⟩aux|\phi_3\rangle_{\mathrm{aux}} corresponds to the case in which ln1+1=jl_{n_1+1}=j we have,

∣ϕ3⟩aux=∑1≤l1<l2<⋯<ln1+1≤j(∑m=1n1+1∣2lm−1⟩C)⊗∣(ln1+1,ln1,…,l2,l1)⟩B.(25)|\phi_3\rangle_{\mathrm{aux}} = \sum_{\substack{1\le l_1<l_2<\\ \cdots<l_{n_1+1}\le j}} \left(\sum_{m=1}^{n_1+1}|2^{l_m-1}\rangle_C\right)\otimes|(l_{n_1+1},l_{n_1},\ldots,l_2,l_1)\rangle_B. \tag*{(25)}

The permutations of the n1+1n_1+1 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 α\alpha does not lie in register AjA_j, since in this case registers BB and CC 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 k<jk<j and there is no need for the permutator over register BB. At the end of this step, the content of register jj will be interchanged for the content of all the other registers, thus achieving antisymmetrization. The last step is then to disentangle register CC.

Costs: Same for symmetrizers and antisymmetrizers, register CC has jj qubits, each of which is used as control over two-particle register SWAP gates that costs O(nqb)O(n_{qb}) Toffoli gates and O(nqb)O(n_{qb}) extra auxiliary qubits. Since each Toffoli can be decomposed into a constant number of single-qubit gates and CNOTs, the total cost is O(jnqb)O(jn_{qb}) single-qubit and CNOT gates and O(nqb)O(n_{qb}) extra auxiliary qubits.

  1. This step is only needed for the symmetrization case. Since registers BB and CC are exactly of the form generated by the UDD algorithm, that is

∣ϕ3⟩aux=∑1≤l1<l2<⋯<ln1+1≤j(∑m=1n1+1∣2lm−1⟩C)⊗(∑m=1n1+12lm−1)B(26)\lvert\phi_{3}\rangle_{\mathrm{aux}} = \sum_{\substack{1\le l_{1}<l_{2}<\\ \cdots<l_{n_{1}+1}\le j}} \left(\sum_{m=1}^{n_{1}+1}\lvert2^{l_{m}-1}\rangle_{C}\right) \otimes \left(\sum_{m=1}^{n_{1}+1}2^{l_{m}-1}\right)_{B} \tag*{(26)}

register CC can be disentangled by applying the UDD algorithm in reverse:

∣ϕ4⟩aux=UDD−1∣ϕ3⟩aux=∣0⟩C⊗∑1≤l1<l2<⋯<ln1+1≤j∣∑m=1n1+12lm−1⟩B.(27)\lvert\phi_{4}\rangle_{\mathrm{aux}}=\mathrm{UDD}^{-1}\lvert\phi_{3}\rangle_{\mathrm{aux}} =\lvert0\rangle_{C}\otimes \sum_{\substack{1\le l_{1}<l_{2}<\\ \cdots<l_{n_{1}+1}\le j}} \left\lvert\sum_{m=1}^{n_{1}+1}2^{l_{m}-1}\right\rangle_{B}. \tag*{(27)}

Costs: O(jlog⁡22j)O(j\log_{2}^{2}j) gates and j+⌈log⁡2j⌉+O(log⁡2j)j+\lceil\log_{2}j\rceil+O(\log_{2}j) extra auxiliary qubits.

  1. For the (anti)symmetrization case, disentangle register (C)B(C)_{B} by undoing step 2, that is, for i=1i=1 to i=ji=j apply a multi-controlled CnqbX(α)C^{n_{qb}}X(\alpha), with the controls being the nqbn_{qb} qubits of subregister AiA_{i} and the target being the (Ci)Bi(C_{i})_{B_{i}} qubit.

Costs: O(jnqb)O(jn_{qb}) single-qubit gates and O(nqb)O(n_{qb}) auxiliary qubits.

Summing up all costs, the total asymptotic complexity for symmetrization is O(jlog⁡22j+jnqb)O(j\log_{2}^{2}j+jn_{qb}) gates and 3j+⌈log⁡2j⌉+O(max⁡(nqb,log⁡2j))3j+\lceil\log_{2}j\rceil+O(\max(n_{qb},\log_{2}j)) auxiliary qubits and for antisymmetrization is O(jnqb)O(jn_{qb}) gates and j+O(nqb)j+O(n_{qb}) 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 S3(P)S_3^{(P)} operator is to construct the symmetric state of three particles. In this example, we consider three registers and two different modes, PP and qq, with the PP mode appearing twice. We assume that registers 1 and 2 are already symmetrized

∣(P,q)S⟩=12(∣P⟩2∣q⟩1+∣q⟩2∣P⟩1).(28)|(P,q)_S\rangle= \frac{1}{\sqrt{2}}\left(|P\rangle_2|q\rangle_1 + |q\rangle_2|P\rangle_1\right). \tag*{(28)}

We want to add register 3, which contains the known mode PP. Thus, the initial state (stored in register AA) is

∣ϕ0⟩=∣P⟩⊗∣(P,q)S⟩=12(∣PPq⟩A+∣PqP⟩A),(29)|\phi_0\rangle= |P\rangle\otimes|(P,q)_S\rangle= \frac{1}{\sqrt{2}}\left(|PPq\rangle_A + |PqP\rangle_A\right), \tag*{(29)}

where we use the notation ∣x3x2x1⟩≡∣x3⟩3∣x2⟩2∣x1⟩1|x_3x_2x_1\rangle\equiv|x_3\rangle_3|x_2\rangle_2|x_1\rangle_1. Following Eq. (15), to keep track of all indices we introduce two auxiliary registers BB and CC, each containing three qubits, initialized as

∣B⟩=∣000⟩B,∣C⟩=13(∣100⟩C+∣010⟩C+∣001⟩C).(30)|B\rangle= |000\rangle_B,\qquad|C\rangle= \frac{1}{\sqrt{3}}\left(|100\rangle_C + |010\rangle_C + |001\rangle_C\right). \tag*{(30)}

So that

∣ϕ1⟩=16(∣100⟩C+∣010⟩C+∣001⟩C)∣000⟩B(∣PPq⟩A+∣PqP⟩A).(31)|\phi_1\rangle= \frac{1}{\sqrt{6}}\left(|100\rangle_C + |010\rangle_C + |001\rangle_C\right)|000\rangle_B\left(|PPq\rangle_A + |PqP\rangle_A\right). \tag*{(31)}

Register BB is used to mark the positions containing the known mode PP. For this, a CnqbX(P)C^{n_{\mathrm{qb}}}X(P) gate, controlled by subregister AiA_i, is applied to each qubit BiB_i. The gate flips BiB_i whenever AiA_i contains the mode PP. This operation can be understood as a CNOT⁡Ai→Bi\operatorname{CNOT}_{A_i\to B_i}. Therefore,

∣000⟩B∣PPq⟩A⟶∣110⟩B∣PPq⟩A,(32)|000\rangle_B|PPq\rangle_A \longrightarrow|110\rangle_B|PPq\rangle_A, \tag*{(32)}
∣000⟩B∣PqP⟩A⟶∣101⟩B∣PqP⟩A,(33)|000\rangle_B|PqP\rangle_A \longrightarrow|101\rangle_B|PqP\rangle_A, \tag*{(33)}

which gives

∣ϕ2⟩=16(∣100⟩C+∣010⟩C+∣001⟩C)(∣110⟩B∣PPq⟩A+∣101⟩B∣PqP⟩A).(34)|\phi_2\rangle= \frac{1}{\sqrt{6}}\left(|100\rangle_C + |010\rangle_C + |001\rangle_C\right)\left(|110\rangle_B|PPq\rangle_A + |101\rangle_B|PqP\rangle_A\right). \tag*{(34)}

Now, we apply the operator of Eq. (17) with $j=3

Uperm=∑k=13∣2k−1⟩⟨2k−1∣C⊗P3kB⊗P3kA+(I⊗3−∑k=13∣2k−1⟩⟨2k−1∣C)⊗IB⊗IA(35)U_{\mathrm{perm}}=\sum_{k=1}^{3}\lvert2^{k-1}\rangle\langle2^{k-1}\rvert_{C}\otimes P^{B}_{3k}\otimes P^{A}_{3k}+\left(I^{\otimes3}-\sum_{k=1}^{3}\lvert2^{k-1}\rangle\langle2^{k-1}\rvert_{C}\right)\otimes I^{B}\otimes I^{A} \tag*{(35)}

where the permutation P3kAP^{A}_{3k} exchanges particle registers 3 and kk, while P3kBP^{B}_{3k} does the same for the auxiliary register BB. Specifically, depending on the state of register CC, the permutation operators applied act as follows,

∣100⟩C⟶P33B⊗P33A=I,(36)\lvert100\rangle_{C}\longrightarrow P^{B}_{33}\otimes P^{A}_{33}=I, \tag*{(36)}
∣010⟩C⟶P32B⊗P32A,(37)\lvert010\rangle_{C}\longrightarrow P^{B}_{32}\otimes P^{A}_{32}, \tag*{(37)}
∣001⟩C⟶P31B⊗P31A.(38)\lvert001\rangle_{C}\longrightarrow P^{B}_{31}\otimes P^{A}_{31}. \tag*{(38)}

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

∣ϕ3⟩=13[∣100⟩C+∣010⟩C2∣110⟩B∣PPq⟩A+∣100⟩C+∣001⟩C2∣101⟩B∣PqP⟩A+∣010⟩C+∣001⟩C2∣011⟩B∣qPP⟩A].(39)\lvert\phi_{3}\rangle=\frac{1}{\sqrt{3}}\left[\frac{\lvert100\rangle_{C}+\lvert010\rangle_{C}}{\sqrt{2}}\lvert110\rangle_{B}\lvert PPq\rangle_{A} +\frac{\lvert100\rangle_{C}+\lvert001\rangle_{C}}{\sqrt{2}}\lvert101\rangle_{B}\lvert PqP\rangle_{A} +\frac{\lvert010\rangle_{C}+\lvert001\rangle_{C}}{\sqrt{2}}\lvert011\rangle_{B}\lvert qPP\rangle_{A}\right]. \tag*{(39)}

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 ∣000⟩C∣110⟩B\lvert000\rangle_{C}\lvert110\rangle_{B}, therefore disentangling register CC if applied in reverse,

∣100⟩C+∣010⟩C2∣110⟩B→UDD−1∣000⟩C∣110⟩B,\frac{\lvert100\rangle_{C}+\lvert010\rangle_{C}}{\sqrt{2}}\lvert110\rangle_{B}\xrightarrow{\mathrm{UDD}^{-1}}\lvert000\rangle_{C}\lvert110\rangle_{B},

and similarly for the ∣101⟩B\lvert101\rangle_{B} and ∣011⟩B\lvert011\rangle_{B} configurations. Thus,

∣ϕ4⟩=∣000⟩C13(∣110⟩B∣PPq⟩A+∣101⟩B∣PqP⟩A+∣011⟩B∣qPP⟩A).(40)\lvert\phi_{4}\rangle=\lvert000\rangle_{C}\frac{1}{\sqrt{3}}\left(\lvert110\rangle_{B}\lvert PPq\rangle_{A}+\lvert101\rangle_{B}\lvert PqP\rangle_{A}+\lvert011\rangle_{B}\lvert qPP\rangle_{A}\right). \tag*{(40)}

Finally, we can repeat the marking operation to return BB to its initial state

∣ϕ5⟩=∣000⟩C∣000⟩B13(∣PPq⟩A+∣PqP⟩A+∣qPP⟩A).(41)\lvert\phi_{5}\rangle=\lvert000\rangle_{C}\lvert000\rangle_{B}\frac{1}{\sqrt{3}}\left(\lvert PPq\rangle_{A}+\lvert PqP\rangle_{A}+\lvert qPP\rangle_{A}\right). \tag*{(41)}

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 BB register initialized in the state ∣110⟩B\lvert110\rangle_B. Thus, the Hamming weight is k=2k = 2, and the occupied positions are l1=2l_1 = 2 and l2=3l_2 = 3.

To implement the algorithm, we introduce two auxiliary registers, DD and EE, with ⌈log⁡2n⌉\lceil\log_2 n\rceil and n−1n - 1 qubits, respectively. In our case, n=3n = 3, so both have 2 qubits.

As explained in § 2.1, in the second step, register EE is used to store the Hamming weight of BB, which is the number of qubits in the ∣1⟩\lvert1\rangle state. Since B=∣110⟩B = \lvert110\rangle, kk equals 2 and therefore, EE rotates ∣00⟩\lvert00\rangle to ∣10⟩\lvert10\rangle,

∣ψ2⟩=∣10⟩E∣00⟩D∣000⟩C∣110⟩B.(42)\lvert\psi_2\rangle= \lvert10\rangle_E \lvert00\rangle_D \lvert000\rangle_C \lvert110\rangle_B . \tag*{(42)}

In the third step, we prepare a superposition of the k=2k = 2 possible values of the counter DD (for this we need EE as an input). In this case, it is sufficient to apply a Hadamard gate to the first qubit of DD, obtaining

∣ψ3⟩=∣10⟩E∣00⟩D+∣01⟩D2∣000⟩C∣110⟩B.(43)\lvert\psi_3\rangle= \lvert10\rangle_E \frac{\lvert00\rangle_D + \lvert01\rangle_D}{\sqrt{2}} \lvert000\rangle_C \lvert110\rangle_B . \tag*{(43)}

In the fourth step, we loop over the qubits of BB, from i=1i = 1 to i=3i = 3. At each position, if Bi=1B_i = 1 and D=0D = 0, we apply a XX gate to CiC_i. Next, if Bi=1B_i = 1, we subtract one from the counter DD, with modulo 4. Omitting the registers EE and BB, which remain invariant, we start from

∣00⟩D∣000⟩C+∣01⟩D∣000⟩C2.(44)\frac{\lvert00\rangle_D \lvert000\rangle_C + \lvert01\rangle_D \lvert000\rangle_C}{\sqrt{2}}. \tag*{(44)}

For i=1i = 1, as B1=0B_1 = 0, no operation is needed. For i=2i = 2, we have B2=1B_2 = 1. In the first term, D=0D = 0, so C2C_2 is activated. In the second term, D=1D = 1, so CC remains unchanged. After subtracting one from DD, we obtain

∣11⟩D∣010⟩C+∣00⟩D∣000⟩C2.(45)\frac{\lvert11\rangle_D \lvert010\rangle_C + \lvert00\rangle_D \lvert000\rangle_C}{\sqrt{2}}. \tag*{(45)}

For i=3i = 3, we also have B3=1B_3 = 1. Now, the counter is zero in the second term, so C3C_3 is activated, while CC remains unchanged in the first term. After subtracting one from DD, we have

∣10⟩D∣010⟩C+∣11⟩D∣100⟩C2.(46)\frac{\lvert10\rangle_D \lvert010\rangle_C + \lvert11\rangle_D \lvert100\rangle_C}{\sqrt{2}}. \tag*{(46)}

Finally, we add k=2k = 2 to DD, recovering its initial value,

∣ψ4⟩=∣10⟩E∣00⟩D∣010⟩C+∣01⟩D∣100⟩C2∣110⟩B.(47)\lvert\psi_4\rangle= \lvert10\rangle_E \frac{\lvert00\rangle_D \lvert010\rangle_C + \lvert01\rangle_D \lvert100\rangle_C}{\sqrt{2}} \lvert110\rangle_B . \tag*{(47)}

In the fifth step, we undo the operations used in the second step to calculate the Hamming weight in BB, returning EE to its initial state. However, DD is entangled with CC, so we have to apply the sixth step to decouple it.

In step 6.1 we use the marked position in CC to activate the corresponding qubits of EE. To do this we use a cascade algorithm, we first activate E2E_2 if C3=1C_3 = 1 and then activate E1E_1 if E2=1E_2 = 1 or C2=1C_2 = 1. In the first term, C=∣010⟩C = \lvert010 \rangle, so we have C2=1C_2 = 1. Therefore E1E_1 is activated, giving E=∣01⟩E = \lvert01 \rangle. In the second term, C3=1C_3 = 1 so E2E_2 is activated first and followed by E1E_1, giving E=∣11⟩E = \lvert11 \rangle. Therefore, we obtain

∣ψ6,1⟩=12(∣01⟩E∣00⟩D∣010⟩C+∣11⟩E∣01⟩D∣100⟩C)∣110⟩B.(48)\lvert\psi_{6,1} \rangle= \frac{1}{\sqrt{2}}\left(\lvert01 \rangle_E \lvert00 \rangle_D \lvert010 \rangle_C + \lvert11 \rangle_E \lvert01 \rangle_D \lvert100 \rangle_C\right)\lvert110 \rangle_B . \tag*{(48)}

In step 6.2, we subtract one from DD for each position where Bi=Ei=1B_i = E_i = 1. The first term remains invariant, while the second term has one subtracted, since B2=E2=1B_2 = E_2 = 1. Thus, both terms have D=0D = 0,

∣ψ6,2⟩=∣00⟩D12(∣01⟩E∣010⟩C+∣11⟩E∣100⟩C)∣110⟩B.(49)\lvert\psi_{6,2} \rangle= \lvert00 \rangle_D \frac{1}{\sqrt{2}}\left(\lvert01 \rangle_E \lvert010 \rangle_C + \lvert11 \rangle_E \lvert100 \rangle_C\right)\lvert110 \rangle_B . \tag*{(49)}

Finally, in step 6.3, we reverse the operations of step 6.1 to return EE to its initial state,

∣ψ6,3⟩=∣00⟩E∣00⟩D∣010⟩C+∣100⟩C2∣110⟩B.(50)\lvert\psi_{6,3} \rangle= \lvert00 \rangle_E \lvert00 \rangle_D \frac{\lvert010 \rangle_C + \lvert100 \rangle_C}{\sqrt{2}}\lvert110 \rangle_B . \tag*{(50)}

Thus, the auxiliary registers DD and EE are finally decoupled and ready for reuse, while CC contains a uniform superposition of the digits in BB, 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 nn registers of nqb+1n_{qb}+1 qubits, each able to store a particle via a presence qubit, in ∣0⟩\lvert0 \rangle if the register is empty or ∣1⟩\lvert1 \rangle if it is occupied, and nqbn_{qb} 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,

aβ†≡sβ†⊗C10 .(51)a^\dagger_\beta\equiv s^\dagger_\beta\otimes C_{10} \, . \tag*{(51)}

where Cij=∣i⟩⟨j∣C_{ij} = |i\rangle\langle j| are control operators acting on the presence qubit,4 sβ†=∣β⟩⟨0…0∣s_{\beta}^{\dagger} = |\beta\rangle\langle0\ldots0|, and sβ=∣0…0⟩⟨β∣s_{\beta} = |0\ldots0\rangle\langle\beta| are the set and scrap operators, which write the quantum numbers of mode β\beta into the selected register.

The aβ†a_{\beta}^{\dagger} operator acts on the empty register ∣Ω⟩=∣0…0⟩∣0⟩|\Omega\rangle= |0\ldots0\rangle|0\rangle as

aβ†∣Ω⟩=sβ†∣0…0⟩⊗C10∣0⟩=∣β⟩∣1⟩(52)a_{\beta}^{\dagger}|\Omega\rangle= s_{\beta}^{\dagger}|0\ldots0\rangle\otimes C_{10}|0\rangle= |\beta\rangle|1\rangle \tag*{(52)}

whereas on an occupied register it returns zero, since C10∣1⟩=0C_{10}|1\rangle= 0.

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

aβ(n)†=∑i=1n[I(n−i)⊗Si†(β)]⋅[∑k=1ik Pi(n)(k=nβ)⋅P0(n−i)⊗(sβ†⊗C10)i⋅Pi−1(i−1)](53)a_{\beta}^{(n)\dagger} = \sum_{i=1}^{n} \left[I^{(n-i)}\otimes S_i^{\dagger}(\beta)\right]\cdot \left[ \sum_{k=1}^{i}\sqrt{k}\,P_i^{(n)}(k=n_{\beta})\cdot P_0^{(n-i)}\otimes \left(s_{\beta}^{\dagger}\otimes C_{10}\right)_i\cdot P_{i-1}^{(i-1)} \right] \tag*{(53)}

where the superscript (n)(n) denotes a memory of nn registers, I(n)I^{(n)} is an identity on nn of them, and Pi(n)P_i^{(n)} is the projector onto states of an nn-register memory with registers 11 to ii occupied and the rest empty. To account for boson enhancement, the operator Pi(n)(k=nβ)P_i^{(n)}(k=n_{\beta}) projects on memories in which exactly kk out of the ii occupied registers store mode β\beta; and the corresponding state is therefore multiplied by k\sqrt{k}. For fermions, the unitary step-symmetrizer Si†(β)S_i^{\dagger}(\beta) is replaced by the unitary step-antisymmetrizer Ai†(β)A_i^{\dagger}(\beta), and the sum over kk collapses to the case k=1k=1, which enforces the Pauli exclusion principle.

Note that Eq. (53) is the sum of operators aβ,i(n)†a_{\beta,i}^{(n)\dagger} acting on different registers. In each of them, the filling pattern is enforced by Pi−1(i−1)P_{i-1}^{(i-1)}, which checks that there are no empty registers to the right of the ii-th register, and P0(n−i)P_0^{(n-i)}, 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 ii-th register via the single-register operator of Eq. (51), followed by its symmetrization with the i−1i-1 particles already stored through Si†(β)S_i^\dagger(\beta).

Notice that because of these projectors and C10C_{10}, the step-symmetrizer Si†(β)S_i^\dagger(\beta) is only applied to configurations with ii active registers where in the ii-th register the mode β\beta 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 h+Xh + X 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.

Evaluation of charm quark to $J/\psi$ fragmentation function

Figure 2. Evaluation of charm quark to J/ψJ/\psi 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 xx or zz, the longitudinal momentum fractions. At extremely low xx, 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 (ρ,P)(\rho, P) at ρ=400MeV/fm3\rho= 400\mathrm{MeV}/\mathrm{fm}^{3}, three times more precise than the present band, would reduce the uncertainty on the radius of a 1.4M⊙1.4M_\odot 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 ∼30\sim30 qubit limit of the simulations, Ref. [10] implemented calculation for two ansatzs:

  1. A color singlet superposition of three quarks with zero or one gluon (3q+3q1g3q + 3q1g).

  2. A color-triplet superposition of one quark with up to two gluons (1q+1q1g+1q2g1q + 1q1g + 1q2g).

As explained in § 4.1, particles are (anti)symmetrized in the moment they are created. The 3q+3q1g3q + 3q1g 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 1q2g1q2g 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, H+G2\mathcal{H} + \mathcal{G}^{2}, cutting the number of Pauli terms of interaction terms of two gluons from O(106)\mathcal{O}(10^{6}) to O(102)\mathcal{O}(10^{2}).

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 O(104)O(10^{4}) 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 TT-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.

  1. 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 HH in the Weyl gauge at hand, as already discussed.

  1. 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.

  1. 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.

  1. 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 ∣l⟩\lvert l\rangle stored in a quantum register BB of jj qubits. To store this count, the algorithm requires an auxiliary register EE of nEn_E qubits initialized to ∣0⟩⊗nE\lvert0\rangle^{\otimes n_E}. This is achieved via Algorithm 1.

Algorithm 1 Step 2 of the UDD Algorithm (§ 2.1)

Require: Register BB in basis state ∣l⟩\lvert l\rangle, auxiliary register EE in state ∣0⟩⊗nE\lvert0\rangle^{\otimes n_E} Ensure: Total number of 1s in ll stored in register EE

  1. for i←0i \leftarrow0 to nqb−1n_{\mathrm{qb}} - 1 do

  2. Apply unit adder to EE if li=1l_i = 1

  3. end for

  4. return Register EE

Expressed in terms of its constituent bits, l=lnqb−1…l1l0l = l_{n_{\mathrm{qb}}-1}\ldots l_1l_0 with li∈{0,1}l_i \in\{0,1\}, the required operation of the unit adder is the following:

  • If li=1⇒∣k⟩E→∣k+1(mod2nE)⟩El_i = 1 \Rightarrow\lvert k\rangle_E \to\lvert k + 1 \pmod{2^{n_E}}\rangle_E (adds it to register EE)

  • If li=0⇒∣k⟩E→∣k⟩El_i = 0 \Rightarrow\lvert k\rangle_E \to\lvert k\rangle_E (it does nothing)

That is, if li=1l_i = 1, the integer stored in EE is incremented by 1 modulo 2nE2^{n_E}; otherwise, the identity operation is performed. This means that the unit adder needs to control that ∣li⟩\lvert l_i\rangle is in state ∣1⟩\lvert1\rangle for it to act over register EE. The only thing left to explain is how the addition itself is implemented in EE.

Decomposing the state of register EE into its individual bits ei∈{0,1}e_i \in\{0,1\}, when adding 1 to a binary number, a bit only changes if all of the bits to its right are 1:

  • Bit e0e_0 always changes.

  • Bit e1e_1 changes only if e0=1e_0 = 1.

  • Bit e2e_2 changes only if e0=1e_0 = 1 and e1=1e_1 = 1.

  • ⋮\vdots

  • Bit eie_i changes only if e0=1e_0 = 1, e1=1e_1 = 1, …\ldots, ei−1=1e_{i-1} = 1.

To do this on our quantum circuit, we note the following: if we modified e0e_0 first, we would destroy the carry information needed to determine whether e1e_1 and e2e_2 should change. Therefore, the circuit is applied from highest to lowest weight (and, as we said before, conditioning each gate on the input bit lil_i). The resulting implementation is shown in Figure 3a.

Quantum circuits for the controlled unit arithmetic operations: (a) unit adder, and (b) unit subtractor

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:

∣li⟩B∣k⟩E↦∣li⟩B∣k−li(mod2nE)⟩E.(54)\lvert l_i\rangle_B \lvert k\rangle_E \mapsto\lvert l_i\rangle_B \lvert k-l_i \pmod{2^{n_E}}\rangle_E . \tag*{(54)}

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 e0e_0 up to the most significant bit enE−1e_{n_E-1}), as depicted in Figure 3b. This implementation is simple but costly in terms of gate executions, requiring O(nE2)O(n_E^2) single-qubit gates and CNOTs. More efficient algorithms achieve linear scaling, see [23].

References

  1. [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. [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. [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. [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. [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. [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. [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. [8]R. W. Hamming, Bell Syst. Tech. J. 29 147-160, 1950.
  9. [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. [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. [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. [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. [13]T. Li, H. Xing and D. B. Zhang, [arXiv:2406.05683 [hep-ph]].arxiv.org/abs/2406.05683
  14. [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. [15]D. Zou et al. [QuNu], Phys. Rev. D 114 (2026), 076001 doi:10.1103/sdvz-1ltn [arXiv:2606.17003 [hep-ph]].DOI
  16. [16]H. W. Lin, W. Wang and Y. Zhao, Prog. Part. Nucl. Phys. 152 (2027), 104274 doi:10.1016/j.ppnp.2026.104274DOI
  17. [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. [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. [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. [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. Gri​​eninger, et al. [arXiv:2611.00214 [hep-ph]].arxiv.org/abs/2611.00214
  21. [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. [22]A. NielMiera, K. Ebira, W. Good and H. W. Lin, [arXiv:2610.31597 [hep-lat]].
  23. [23]C. Gidney, Quantum 2 (2018), 74 doi:10.22331/q-2018-06-18-74 [arXiv:1709.06648 [quant-ph]].DOI

Paper details

vlnc:W_v5efqgwz
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents